Attachment 840742 Details for Bug 1046034 – Preprocessed source

Preprocessed source

ccUGoTRp.out (text/x-csrc), 5.64 MB, created by michaelrst on 2013-12-23 10:14:00 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: michaelrst

Created: 2013-12-23 10:14:00 UTC

Size: 5.64 MB

patch

obsolete

>// /usr/libexec/gcc/x86_64-redhat-linux/4.8.2/cc1plus -quiet -v -MMD src/wildfire.d -MF src/wildfire.d -MP -MT src/wildfire.d -D_GNU_SOURCE ../src/wildfire.cpp -quiet -dumpbase wildfire.cpp -mtune=generic -march=x86-64 -auxbase-strip src/wildfire.o -O2 -Wall -std=c++11 -version -fmessage-length=0 -o - -frandom-seed=0
># 1 "../src/wildfire.cpp"
># 1 "<command-line>"
># 1 "/usr/include/stdc-predef.h" 1 3 4
># 1 "<command-line>" 2
># 1 "../src/wildfire.cpp"
># 14 "../src/wildfire.cpp"
># 1 "../src/wildfire.h" 1
># 17 "../src/wildfire.h"
># 1 "../src/types.h" 1
># 16 "../src/types.h"
>typedef unsigned long long int uint64x_t;
>typedef unsigned int uint32_t;
>typedef unsigned short uint16_t;
>typedef unsigned char uint8_t;
>typedef signed int sint32_t;
>typedef signed short sint16_t;
>typedef signed char sint8_t;
>
># 1 "/usr/include/c++/4.8.2/complex" 1 3
># 39 "/usr/include/c++/4.8.2/complex" 3
> 
># 40 "/usr/include/c++/4.8.2/complex" 3
>
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 1 3
>
>
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 4 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 2 3
># 1855 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 3
>namespace std
>{
> typedef long unsigned int size_t;
> typedef long int ptrdiff_t;
>
>
> typedef decltype(nullptr) nullptr_t;
>
>}
># 2097 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 3
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/os_defines.h" 1 3
># 39 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/os_defines.h" 3
># 1 "/usr/include/features.h" 1 3 4
># 364 "/usr/include/features.h" 3 4
># 1 "/usr/include/sys/cdefs.h" 1 3 4
># 385 "/usr/include/sys/cdefs.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 386 "/usr/include/sys/cdefs.h" 2 3 4
># 365 "/usr/include/features.h" 2 3 4
># 388 "/usr/include/features.h" 3 4
># 1 "/usr/include/gnu/stubs.h" 1 3 4
># 10 "/usr/include/gnu/stubs.h" 3 4
># 1 "/usr/include/gnu/stubs-64.h" 1 3 4
># 11 "/usr/include/gnu/stubs.h" 2 3 4
># 389 "/usr/include/features.h" 2 3 4
># 40 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/os_defines.h" 2 3
># 2098 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 2 3
>
>
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/cpu_defines.h" 1 3
># 2101 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 2 3
># 42 "/usr/include/c++/4.8.2/complex" 2 3
># 1 "/usr/include/c++/4.8.2/bits/cpp_type_traits.h" 1 3
># 35 "/usr/include/c++/4.8.2/bits/cpp_type_traits.h" 3
> 
># 36 "/usr/include/c++/4.8.2/bits/cpp_type_traits.h" 3
># 68 "/usr/include/c++/4.8.2/bits/cpp_type_traits.h" 3
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Iterator, typename _Container>
> class __normal_iterator;
>
>
>}
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> struct __true_type { };
> struct __false_type { };
>
> template<bool>
> struct __truth_type
> { typedef __false_type __type; };
>
> template<>
> struct __truth_type<true>
> { typedef __true_type __type; };
>
>
>
> template<class _Sp, class _Tp>
> struct __traitor
> {
> enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
> typedef typename __truth_type<__value>::__type __type;
> };
>
>
> template<typename, typename>
> struct __are_same
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<typename _Tp>
> struct __are_same<_Tp, _Tp>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<typename _Tp>
> struct __is_void
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<>
> struct __is_void<void>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_integer
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
>
>
>
> template<>
> struct __is_integer<bool>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<signed char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<>
> struct __is_integer<wchar_t>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
> template<>
> struct __is_integer<char16_t>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<char32_t>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<>
> struct __is_integer<short>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned short>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<int>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned int>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<long>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned long>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<long long>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned long long>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_floating
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
>
> template<>
> struct __is_floating<float>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_floating<double>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_floating<long double>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_pointer
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<typename _Tp>
> struct __is_pointer<_Tp*>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_normal_iterator
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<typename _Iterator, typename _Container>
> struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
> _Container> >
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_arithmetic
> : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
> { };
>
>
>
>
> template<typename _Tp>
> struct __is_fundamental
> : public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
> { };
>
>
>
>
> template<typename _Tp>
> struct __is_scalar
> : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
> { };
>
>
>
>
> template<typename _Tp>
> struct __is_char
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<>
> struct __is_char<char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<>
> struct __is_char<wchar_t>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<typename _Tp>
> struct __is_byte
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<>
> struct __is_byte<char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_byte<signed char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_byte<unsigned char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_move_iterator
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
>
> template<typename _Iterator>
> class move_iterator;
>
> template<typename _Iterator>
> struct __is_move_iterator< move_iterator<_Iterator> >
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>}
># 43 "/usr/include/c++/4.8.2/complex" 2 3
># 1 "/usr/include/c++/4.8.2/ext/type_traits.h" 1 3
># 32 "/usr/include/c++/4.8.2/ext/type_traits.h" 3
> 
># 33 "/usr/include/c++/4.8.2/ext/type_traits.h" 3
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<bool, typename>
> struct __enable_if
> { };
>
> template<typename _Tp>
> struct __enable_if<true, _Tp>
> { typedef _Tp __type; };
>
>
>
> template<bool _Cond, typename _Iftrue, typename _Iffalse>
> struct __conditional_type
> { typedef _Iftrue __type; };
>
> template<typename _Iftrue, typename _Iffalse>
> struct __conditional_type<false, _Iftrue, _Iffalse>
> { typedef _Iffalse __type; };
>
>
>
> template<typename _Tp>
> struct __add_unsigned
> {
> private:
> typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
>
> public:
> typedef typename __if_type::__type __type;
> };
>
> template<>
> struct __add_unsigned<char>
> { typedef unsigned char __type; };
>
> template<>
> struct __add_unsigned<signed char>
> { typedef unsigned char __type; };
>
> template<>
> struct __add_unsigned<short>
> { typedef unsigned short __type; };
>
> template<>
> struct __add_unsigned<int>
> { typedef unsigned int __type; };
>
> template<>
> struct __add_unsigned<long>
> { typedef unsigned long __type; };
>
> template<>
> struct __add_unsigned<long long>
> { typedef unsigned long long __type; };
>
>
> template<>
> struct __add_unsigned<bool>;
>
> template<>
> struct __add_unsigned<wchar_t>;
>
>
>
> template<typename _Tp>
> struct __remove_unsigned
> {
> private:
> typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
>
> public:
> typedef typename __if_type::__type __type;
> };
>
> template<>
> struct __remove_unsigned<char>
> { typedef signed char __type; };
>
> template<>
> struct __remove_unsigned<unsigned char>
> { typedef signed char __type; };
>
> template<>
> struct __remove_unsigned<unsigned short>
> { typedef short __type; };
>
> template<>
> struct __remove_unsigned<unsigned int>
> { typedef int __type; };
>
> template<>
> struct __remove_unsigned<unsigned long>
> { typedef long __type; };
>
> template<>
> struct __remove_unsigned<unsigned long long>
> { typedef long long __type; };
>
>
> template<>
> struct __remove_unsigned<bool>;
>
> template<>
> struct __remove_unsigned<wchar_t>;
>
>
>
> template<typename _Type>
> inline bool
> __is_null_pointer(_Type* __ptr)
> { return __ptr == 0; }
>
> template<typename _Type>
> inline bool
> __is_null_pointer(_Type)
> { return false; }
>
>
>
> template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
> struct __promote
> { typedef double __type; };
>
>
>
>
> template<typename _Tp>
> struct __promote<_Tp, false>
> { };
>
> template<>
> struct __promote<long double>
> { typedef long double __type; };
>
> template<>
> struct __promote<double>
> { typedef double __type; };
>
> template<>
> struct __promote<float>
> { typedef float __type; };
>
> template<typename _Tp, typename _Up,
> typename _Tp2 = typename __promote<_Tp>::__type,
> typename _Up2 = typename __promote<_Up>::__type>
> struct __promote_2
> {
> typedef __typeof__(_Tp2() + _Up2()) __type;
> };
>
> template<typename _Tp, typename _Up, typename _Vp,
> typename _Tp2 = typename __promote<_Tp>::__type,
> typename _Up2 = typename __promote<_Up>::__type,
> typename _Vp2 = typename __promote<_Vp>::__type>
> struct __promote_3
> {
> typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
> };
>
> template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
> typename _Tp2 = typename __promote<_Tp>::__type,
> typename _Up2 = typename __promote<_Up>::__type,
> typename _Vp2 = typename __promote<_Vp>::__type,
> typename _Wp2 = typename __promote<_Wp>::__type>
> struct __promote_4
> {
> typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
> };
>
>
>}
># 44 "/usr/include/c++/4.8.2/complex" 2 3
># 1 "/usr/include/c++/4.8.2/cmath" 1 3
># 39 "/usr/include/c++/4.8.2/cmath" 3
> 
># 40 "/usr/include/c++/4.8.2/cmath" 3
>
>
>
>
># 1 "/usr/include/math.h" 1 3 4
># 28 "/usr/include/math.h" 3 4
>extern "C" {
>
>
>
># 1 "/usr/include/bits/huge_val.h" 1 3 4
># 33 "/usr/include/math.h" 2 3 4
>
># 1 "/usr/include/bits/huge_valf.h" 1 3 4
># 35 "/usr/include/math.h" 2 3 4
># 1 "/usr/include/bits/huge_vall.h" 1 3 4
># 36 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/inf.h" 1 3 4
># 39 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/nan.h" 1 3 4
># 42 "/usr/include/math.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/mathdef.h" 1 3 4
># 28 "/usr/include/bits/mathdef.h" 3 4
>typedef float float_t;
>typedef double double_t;
># 46 "/usr/include/math.h" 2 3 4
># 69 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 52 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
>
>extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
>
>extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
>
>extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
>
>
>extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
>
>extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
>
>extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
>
>
>
>
>extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
>
>extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
>
>extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
>
>
>
>
>extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ()
> ;
>
>
>
>
>
>extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
>
>extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
>
>extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
>
>
>
>
>
>
>
>extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
>
>
>extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
>
>
>extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
>
>
>extern double log (double __x) throw (); extern double __log (double __x) throw ();
>
>
>extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
>
>
>extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
>
>extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();
>
>
>
>
>
>extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
>
>
>extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
>
>
>extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
>
>
>
>
>
>
>extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
>
>
>extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
>
>
>
>
>
>
>
>
>extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
>
>
>extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
>
>
>
>
>
>extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
>
>
>
>
>
>
>extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
>
>
>
>
>
>
>
>
>extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
>
>
>extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
>
>
>extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
>
>
>extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
>
>
>
>
>extern int __isinf (double __value) throw () __attribute__ ((__const__));
>
>
>extern int __finite (double __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int isinf (double __value) throw () __attribute__ ((__const__));
>
>
>extern int finite (double __value) throw () __attribute__ ((__const__));
>
>
>extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
>
>
>
>extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
>
>
>
>
>
>extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>extern double nan (const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (const char *__tagb) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnan (double __value) throw () __attribute__ ((__const__));
>
>
>
>extern int isnan (double __value) throw () __attribute__ ((__const__));
>
>
>extern double j0 (double) throw (); extern double __j0 (double) throw ();
>extern double j1 (double) throw (); extern double __j1 (double) throw ();
>extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
>extern double y0 (double) throw (); extern double __y0 (double) throw ();
>extern double y1 (double) throw (); extern double __y1 (double) throw ();
>extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
>
>
>
>
>
>
>extern double erf (double) throw (); extern double __erf (double) throw ();
>extern double erfc (double) throw (); extern double __erfc (double) throw ();
>extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
>
>
>
>
>
>
>extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
>
>
>
>
>
>extern double gamma (double) throw (); extern double __gamma (double) throw ();
>
>
>
>
>
>
>extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
>
>
>
>
>
>
>
>extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
>
>
>extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));
>
>extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
>
>
>
>extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
>
>
>
>extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
>
>
>
>
>extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
>
>
>
>extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
>
>
>
>extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
>
>
>
>extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
>__extension__
>extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
>
>
>
>extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
>__extension__
>extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
>
>
>
>extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
>
>
>extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));
>
>
>extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));
>
>
>
>extern int __fpclassify (double __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbit (double __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
>
>
>
>
>
>
>
>
>extern int __issignaling (double __value) throw ()
> __attribute__ ((__const__));
>
>
>
>
>extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
># 70 "/usr/include/math.h" 2 3 4
># 88 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 52 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
>
>extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
>
>extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
>
>extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
>
>
>extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
>
>extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
>
>extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
>
>
>
>
>extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
>
>extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
>
>extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
>
>
>
>
>extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ()
> ;
>
>
>
>
>
>extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
>
>extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
>
>extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
>
>
>
>
>
>
>
>extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
>
>
>extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
>
>
>extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
>
>
>extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
>
>
>extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
>
>
>extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
>
>extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();
>
>
>
>
>
>extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
>
>
>extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
>
>
>extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
>
>
>
>
>
>
>extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
>
>
>extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
>
>
>
>
>
>
>
>
>extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
>
>
>extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
>
>
>
>
>
>extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
>
>
>
>
>
>
>extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
>
>
>
>
>
>
>
>
>extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
>
>
>
>
>extern int __isinff (float __value) throw () __attribute__ ((__const__));
>
>
>extern int __finitef (float __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int isinff (float __value) throw () __attribute__ ((__const__));
>
>
>extern int finitef (float __value) throw () __attribute__ ((__const__));
>
>
>extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
>
>
>
>extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
>
>
>
>
>
>extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>extern float nanf (const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (const char *__tagb) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanf (float __value) throw () __attribute__ ((__const__));
>
>
>
>extern int isnanf (float __value) throw () __attribute__ ((__const__));
>
>
>extern float j0f (float) throw (); extern float __j0f (float) throw ();
>extern float j1f (float) throw (); extern float __j1f (float) throw ();
>extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
>extern float y0f (float) throw (); extern float __y0f (float) throw ();
>extern float y1f (float) throw (); extern float __y1f (float) throw ();
>extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
>
>
>
>
>
>
>extern float erff (float) throw (); extern float __erff (float) throw ();
>extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
>extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
>
>
>
>
>
>
>extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
>
>
>
>
>
>extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
>
>
>
>
>
>
>extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
>
>
>
>
>
>
>
>extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
>
>
>extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));
>
>extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
>
>
>
>extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
>
>
>
>extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
>
>
>
>
>extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
>
>
>
>extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
>
>
>
>extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
>
>
>
>extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
>__extension__
>extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
>
>
>
>extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
>__extension__
>extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
>
>
>
>extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
>
>
>extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));
>
>
>extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));
>
>
>
>extern int __fpclassifyf (float __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbitf (float __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
>
>
>
>
>
>
>
>
>extern int __issignalingf (float __value) throw ()
> __attribute__ ((__const__));
>
>
>
>
>extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
># 89 "/usr/include/math.h" 2 3 4
># 132 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 52 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
>
>extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
>
>extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
>
>extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
>
>
>extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
>
>extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
>
>extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
>
>
>
>
>extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
>
>extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
>
>extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
>
>
>
>
>extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ()
> ;
>
>
>
>
>
>extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
>
>extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
>
>extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
>
>
>
>
>
>
>
>extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
>
>
>extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
>
>
>extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
>
>
>extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
>
>
>extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
>
>
>extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
>
>extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();
>
>
>
>
>
>extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
>
>
>extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
>
>
>extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
>
>
>
>
>
>
>extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
>
>
>extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
>
>
>
>
>
>
>
>
>extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
>
>
>extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
>
>
>
>
>
>extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
>
>
>
>
>
>
>extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
>
>
>
>
>
>
>
>
>extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
>
>
>
>
>extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern int __finitel (long double __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int isinfl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern int finitel (long double __value) throw () __attribute__ ((__const__));
>
>
>extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
>
>
>
>extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
>
>
>
>
>
>extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>extern long double nanl (const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (const char *__tagb) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
>
>
>
>extern int isnanl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
>extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
>extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
>extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
>extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
>extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
>
>
>
>
>
>
>extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
>extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
>extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
>
>
>
>
>
>
>extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
>
>
>
>
>
>extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
>
>
>
>
>
>
>extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
>
>
>
>
>
>
>
>extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
>
>
>extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
>
>
>
>extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
>
>
>
>extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
>
>
>
>
>extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
>
>
>
>extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
>
>
>
>extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
>
>
>
>extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
>__extension__
>extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
>
>
>
>extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
>__extension__
>extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
>
>
>
>extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
>
>
>extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern int __fpclassifyl (long double __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbitl (long double __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
>
>
>
>
>
>
>
>
>extern int __issignalingl (long double __value) throw ()
> __attribute__ ((__const__));
>
>
>
>
>extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
># 133 "/usr/include/math.h" 2 3 4
># 148 "/usr/include/math.h" 3 4
>extern int signgam;
># 189 "/usr/include/math.h" 3 4
>enum
> {
> FP_NAN =
>
> 0,
> FP_INFINITE =
>
> 1,
> FP_ZERO =
>
> 2,
> FP_SUBNORMAL =
>
> 3,
> FP_NORMAL =
>
> 4
> };
># 301 "/usr/include/math.h" 3 4
>typedef enum
>{
> _IEEE_ = -1,
> _SVID_,
> _XOPEN_,
> _POSIX_,
> _ISOC_
>} _LIB_VERSION_TYPE;
>
>
>
>
>extern _LIB_VERSION_TYPE _LIB_VERSION;
># 324 "/usr/include/math.h" 3 4
>struct __exception
>
>
>
> {
> int type;
> char *name;
> double arg1;
> double arg2;
> double retval;
> };
>
>
>extern int matherr (struct __exception *__exc) throw ();
># 426 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathinline.h" 1 3 4
># 123 "/usr/include/bits/mathinline.h" 3 4
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) __signbitf (float __x) throw ()
>{
>
> int __m;
> __asm ("pmovmskb %1, %0" : "=r" (__m) : "x" (__x));
> return (__m & 0x8) != 0;
>
>
>
>
>}
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) __signbit (double __x) throw ()
>{
>
> int __m;
> __asm ("pmovmskb %1, %0" : "=r" (__m) : "x" (__x));
> return (__m & 0x80) != 0;
>
>
>
>
>}
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) __signbitl (long double __x) throw ()
>{
> __extension__ union { long double __l; int __i[3]; } __u = { __l: __x };
> return (__u.__i[2] & 0x8000) != 0;
>}
>
>
># 427 "/usr/include/math.h" 2 3 4
># 488 "/usr/include/math.h" 3 4
>}
># 45 "/usr/include/c++/4.8.2/cmath" 2 3
># 75 "/usr/include/c++/4.8.2/cmath" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> inline constexpr double
> abs(double __x)
> { return __builtin_fabs(__x); }
>
>
>
> inline constexpr float
> abs(float __x)
> { return __builtin_fabsf(__x); }
>
> inline constexpr long double
> abs(long double __x)
> { return __builtin_fabsl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> abs(_Tp __x)
> { return __builtin_fabs(__x); }
>
> using ::acos;
>
>
> inline constexpr float
> acos(float __x)
> { return __builtin_acosf(__x); }
>
> inline constexpr long double
> acos(long double __x)
> { return __builtin_acosl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> acos(_Tp __x)
> { return __builtin_acos(__x); }
>
> using ::asin;
>
>
> inline constexpr float
> asin(float __x)
> { return __builtin_asinf(__x); }
>
> inline constexpr long double
> asin(long double __x)
> { return __builtin_asinl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> asin(_Tp __x)
> { return __builtin_asin(__x); }
>
> using ::atan;
>
>
> inline constexpr float
> atan(float __x)
> { return __builtin_atanf(__x); }
>
> inline constexpr long double
> atan(long double __x)
> { return __builtin_atanl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> atan(_Tp __x)
> { return __builtin_atan(__x); }
>
> using ::atan2;
>
>
> inline constexpr float
> atan2(float __y, float __x)
> { return __builtin_atan2f(__y, __x); }
>
> inline constexpr long double
> atan2(long double __y, long double __x)
> { return __builtin_atan2l(__y, __x); }
>
>
> template<typename _Tp, typename _Up>
> inline constexpr
> typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> atan2(_Tp __y, _Up __x)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return atan2(__type(__y), __type(__x));
> }
>
> using ::ceil;
>
>
> inline constexpr float
> ceil(float __x)
> { return __builtin_ceilf(__x); }
>
> inline constexpr long double
> ceil(long double __x)
> { return __builtin_ceill(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> ceil(_Tp __x)
> { return __builtin_ceil(__x); }
>
> using ::cos;
>
>
> inline constexpr float
> cos(float __x)
> { return __builtin_cosf(__x); }
>
> inline constexpr long double
> cos(long double __x)
> { return __builtin_cosl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> cos(_Tp __x)
> { return __builtin_cos(__x); }
>
> using ::cosh;
>
>
> inline constexpr float
> cosh(float __x)
> { return __builtin_coshf(__x); }
>
> inline constexpr long double
> cosh(long double __x)
> { return __builtin_coshl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> cosh(_Tp __x)
> { return __builtin_cosh(__x); }
>
> using ::exp;
>
>
> inline constexpr float
> exp(float __x)
> { return __builtin_expf(__x); }
>
> inline constexpr long double
> exp(long double __x)
> { return __builtin_expl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> exp(_Tp __x)
> { return __builtin_exp(__x); }
>
> using ::fabs;
>
>
> inline constexpr float
> fabs(float __x)
> { return __builtin_fabsf(__x); }
>
> inline constexpr long double
> fabs(long double __x)
> { return __builtin_fabsl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> fabs(_Tp __x)
> { return __builtin_fabs(__x); }
>
> using ::floor;
>
>
> inline constexpr float
> floor(float __x)
> { return __builtin_floorf(__x); }
>
> inline constexpr long double
> floor(long double __x)
> { return __builtin_floorl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> floor(_Tp __x)
> { return __builtin_floor(__x); }
>
> using ::fmod;
>
>
> inline constexpr float
> fmod(float __x, float __y)
> { return __builtin_fmodf(__x, __y); }
>
> inline constexpr long double
> fmod(long double __x, long double __y)
> { return __builtin_fmodl(__x, __y); }
>
>
> template<typename _Tp, typename _Up>
> inline constexpr
> typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> fmod(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return fmod(__type(__x), __type(__y));
> }
>
> using ::frexp;
>
>
> inline float
> frexp(float __x, int* __exp)
> { return __builtin_frexpf(__x, __exp); }
>
> inline long double
> frexp(long double __x, int* __exp)
> { return __builtin_frexpl(__x, __exp); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> frexp(_Tp __x, int* __exp)
> { return __builtin_frexp(__x, __exp); }
>
> using ::ldexp;
>
>
> inline constexpr float
> ldexp(float __x, int __exp)
> { return __builtin_ldexpf(__x, __exp); }
>
> inline constexpr long double
> ldexp(long double __x, int __exp)
> { return __builtin_ldexpl(__x, __exp); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> ldexp(_Tp __x, int __exp)
> { return __builtin_ldexp(__x, __exp); }
>
> using ::log;
>
>
> inline constexpr float
> log(float __x)
> { return __builtin_logf(__x); }
>
> inline constexpr long double
> log(long double __x)
> { return __builtin_logl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> log(_Tp __x)
> { return __builtin_log(__x); }
>
> using ::log10;
>
>
> inline constexpr float
> log10(float __x)
> { return __builtin_log10f(__x); }
>
> inline constexpr long double
> log10(long double __x)
> { return __builtin_log10l(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> log10(_Tp __x)
> { return __builtin_log10(__x); }
>
> using ::modf;
>
>
> inline float
> modf(float __x, float* __iptr)
> { return __builtin_modff(__x, __iptr); }
>
> inline long double
> modf(long double __x, long double* __iptr)
> { return __builtin_modfl(__x, __iptr); }
>
>
> using ::pow;
>
>
> inline constexpr float
> pow(float __x, float __y)
> { return __builtin_powf(__x, __y); }
>
> inline constexpr long double
> pow(long double __x, long double __y)
> { return __builtin_powl(__x, __y); }
># 431 "/usr/include/c++/4.8.2/cmath" 3
> template<typename _Tp, typename _Up>
> inline constexpr
> 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 constexpr float
> sin(float __x)
> { return __builtin_sinf(__x); }
>
> inline constexpr long double
> sin(long double __x)
> { return __builtin_sinl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> sin(_Tp __x)
> { return __builtin_sin(__x); }
>
> using ::sinh;
>
>
> inline constexpr float
> sinh(float __x)
> { return __builtin_sinhf(__x); }
>
> inline constexpr long double
> sinh(long double __x)
> { return __builtin_sinhl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> sinh(_Tp __x)
> { return __builtin_sinh(__x); }
>
> using ::sqrt;
>
>
> inline constexpr float
> sqrt(float __x)
> { return __builtin_sqrtf(__x); }
>
> inline constexpr long double
> sqrt(long double __x)
> { return __builtin_sqrtl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> sqrt(_Tp __x)
> { return __builtin_sqrt(__x); }
>
> using ::tan;
>
>
> inline constexpr float
> tan(float __x)
> { return __builtin_tanf(__x); }
>
> inline constexpr long double
> tan(long double __x)
> { return __builtin_tanl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> tan(_Tp __x)
> { return __builtin_tan(__x); }
>
> using ::tanh;
>
>
> inline constexpr float
> tanh(float __x)
> { return __builtin_tanhf(__x); }
>
> inline constexpr long double
> tanh(long double __x)
> { return __builtin_tanhl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> tanh(_Tp __x)
> { return __builtin_tanh(__x); }
>
>
>}
># 555 "/usr/include/c++/4.8.2/cmath" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> constexpr int
> fpclassify(float __x)
> { return __builtin_fpclassify(0, 1, 4,
> 3, 2, __x); }
>
> constexpr int
> fpclassify(double __x)
> { return __builtin_fpclassify(0, 1, 4,
> 3, 2, __x); }
>
> constexpr int
> fpclassify(long double __x)
> { return __builtin_fpclassify(0, 1, 4,
> 3, 2, __x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> int>::__type
> fpclassify(_Tp __x)
> { return __x != 0 ? 4 : 2; }
>
> constexpr bool
> isfinite(float __x)
> { return __builtin_isfinite(__x); }
>
> constexpr bool
> isfinite(double __x)
> { return __builtin_isfinite(__x); }
>
> constexpr bool
> isfinite(long double __x)
> { return __builtin_isfinite(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> bool>::__type
> isfinite(_Tp __x)
> { return true; }
>
> constexpr bool
> isinf(float __x)
> { return __builtin_isinf(__x); }
>
> constexpr bool
> isinf(double __x)
> { return __builtin_isinf(__x); }
>
> constexpr bool
> isinf(long double __x)
> { return __builtin_isinf(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> bool>::__type
> isinf(_Tp __x)
> { return false; }
>
> constexpr bool
> isnan(float __x)
> { return __builtin_isnan(__x); }
>
> constexpr bool
> isnan(double __x)
> { return __builtin_isnan(__x); }
>
> constexpr bool
> isnan(long double __x)
> { return __builtin_isnan(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> bool>::__type
> isnan(_Tp __x)
> { return false; }
>
> constexpr bool
> isnormal(float __x)
> { return __builtin_isnormal(__x); }
>
> constexpr bool
> isnormal(double __x)
> { return __builtin_isnormal(__x); }
>
> constexpr bool
> isnormal(long double __x)
> { return __builtin_isnormal(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> bool>::__type
> isnormal(_Tp __x)
> { return __x != 0 ? true : false; }
>
> constexpr bool
> signbit(float __x)
> { return __builtin_signbit(__x); }
>
> constexpr bool
> signbit(double __x)
> { return __builtin_signbit(__x); }
>
> constexpr bool
> signbit(long double __x)
> { return __builtin_signbit(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> bool>::__type
> signbit(_Tp __x)
> { return __x < 0 ? true : false; }
>
> constexpr bool
> isgreater(float __x, float __y)
> { return __builtin_isgreater(__x, __y); }
>
> constexpr bool
> isgreater(double __x, double __y)
> { return __builtin_isgreater(__x, __y); }
>
> constexpr bool
> isgreater(long double __x, long double __y)
> { return __builtin_isgreater(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> isgreater(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_isgreater(__type(__x), __type(__y));
> }
>
> constexpr bool
> isgreaterequal(float __x, float __y)
> { return __builtin_isgreaterequal(__x, __y); }
>
> constexpr bool
> isgreaterequal(double __x, double __y)
> { return __builtin_isgreaterequal(__x, __y); }
>
> constexpr bool
> isgreaterequal(long double __x, long double __y)
> { return __builtin_isgreaterequal(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> isgreaterequal(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_isgreaterequal(__type(__x), __type(__y));
> }
>
> constexpr bool
> isless(float __x, float __y)
> { return __builtin_isless(__x, __y); }
>
> constexpr bool
> isless(double __x, double __y)
> { return __builtin_isless(__x, __y); }
>
> constexpr bool
> isless(long double __x, long double __y)
> { return __builtin_isless(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> isless(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_isless(__type(__x), __type(__y));
> }
>
> constexpr bool
> islessequal(float __x, float __y)
> { return __builtin_islessequal(__x, __y); }
>
> constexpr bool
> islessequal(double __x, double __y)
> { return __builtin_islessequal(__x, __y); }
>
> constexpr bool
> islessequal(long double __x, long double __y)
> { return __builtin_islessequal(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> islessequal(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_islessequal(__type(__x), __type(__y));
> }
>
> constexpr bool
> islessgreater(float __x, float __y)
> { return __builtin_islessgreater(__x, __y); }
>
> constexpr bool
> islessgreater(double __x, double __y)
> { return __builtin_islessgreater(__x, __y); }
>
> constexpr bool
> islessgreater(long double __x, long double __y)
> { return __builtin_islessgreater(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> islessgreater(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_islessgreater(__type(__x), __type(__y));
> }
>
> constexpr bool
> isunordered(float __x, float __y)
> { return __builtin_isunordered(__x, __y); }
>
> constexpr bool
> isunordered(double __x, double __y)
> { return __builtin_isunordered(__x, __y); }
>
> constexpr bool
> isunordered(long double __x, long double __y)
> { return __builtin_isunordered(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> isunordered(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_isunordered(__type(__x), __type(__y));
> }
># 916 "/usr/include/c++/4.8.2/cmath" 3
>
>}
># 1032 "/usr/include/c++/4.8.2/cmath" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> using ::double_t;
> using ::float_t;
>
>
> 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 ::remquof;
> using ::remquol;
>
> 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;
>
>
> constexpr float
> acosh(float __x)
> { return __builtin_acoshf(__x); }
>
> constexpr long double
> acosh(long double __x)
> { return __builtin_acoshl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> acosh(_Tp __x)
> { return __builtin_acosh(__x); }
>
> constexpr float
> asinh(float __x)
> { return __builtin_asinhf(__x); }
>
> constexpr long double
> asinh(long double __x)
> { return __builtin_asinhl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> asinh(_Tp __x)
> { return __builtin_asinh(__x); }
>
> constexpr float
> atanh(float __x)
> { return __builtin_atanhf(__x); }
>
> constexpr long double
> atanh(long double __x)
> { return __builtin_atanhl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> atanh(_Tp __x)
> { return __builtin_atanh(__x); }
>
> constexpr float
> cbrt(float __x)
> { return __builtin_cbrtf(__x); }
>
> constexpr long double
> cbrt(long double __x)
> { return __builtin_cbrtl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> cbrt(_Tp __x)
> { return __builtin_cbrt(__x); }
>
> constexpr float
> copysign(float __x, float __y)
> { return __builtin_copysignf(__x, __y); }
>
> constexpr long double
> copysign(long double __x, long double __y)
> { return __builtin_copysignl(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr 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));
> }
>
> constexpr float
> erf(float __x)
> { return __builtin_erff(__x); }
>
> constexpr long double
> erf(long double __x)
> { return __builtin_erfl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> erf(_Tp __x)
> { return __builtin_erf(__x); }
>
> constexpr float
> erfc(float __x)
> { return __builtin_erfcf(__x); }
>
> constexpr long double
> erfc(long double __x)
> { return __builtin_erfcl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> erfc(_Tp __x)
> { return __builtin_erfc(__x); }
>
> constexpr float
> exp2(float __x)
> { return __builtin_exp2f(__x); }
>
> constexpr long double
> exp2(long double __x)
> { return __builtin_exp2l(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> exp2(_Tp __x)
> { return __builtin_exp2(__x); }
>
> constexpr float
> expm1(float __x)
> { return __builtin_expm1f(__x); }
>
> constexpr long double
> expm1(long double __x)
> { return __builtin_expm1l(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> expm1(_Tp __x)
> { return __builtin_expm1(__x); }
>
> constexpr float
> fdim(float __x, float __y)
> { return __builtin_fdimf(__x, __y); }
>
> constexpr long double
> fdim(long double __x, long double __y)
> { return __builtin_fdiml(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr 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));
> }
>
> constexpr float
> fma(float __x, float __y, float __z)
> { return __builtin_fmaf(__x, __y, __z); }
>
> constexpr 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>
> constexpr 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));
> }
>
> constexpr float
> fmax(float __x, float __y)
> { return __builtin_fmaxf(__x, __y); }
>
> constexpr long double
> fmax(long double __x, long double __y)
> { return __builtin_fmaxl(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr 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));
> }
>
> constexpr float
> fmin(float __x, float __y)
> { return __builtin_fminf(__x, __y); }
>
> constexpr long double
> fmin(long double __x, long double __y)
> { return __builtin_fminl(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr 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));
> }
>
> constexpr float
> hypot(float __x, float __y)
> { return __builtin_hypotf(__x, __y); }
>
> constexpr long double
> hypot(long double __x, long double __y)
> { return __builtin_hypotl(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr 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));
> }
>
> constexpr int
> ilogb(float __x)
> { return __builtin_ilogbf(__x); }
>
> constexpr int
> ilogb(long double __x)
> { return __builtin_ilogbl(__x); }
>
> template<typename _Tp>
> constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> int>::__type
> ilogb(_Tp __x)
> { return __builtin_ilogb(__x); }
>
> constexpr float
> lgamma(float __x)
> { return __builtin_lgammaf(__x); }
>
> constexpr long double
> lgamma(long double __x)
> { return __builtin_lgammal(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> lgamma(_Tp __x)
> { return __builtin_lgamma(__x); }
>
> constexpr long long
> llrint(float __x)
> { return __builtin_llrintf(__x); }
>
> constexpr long long
> llrint(long double __x)
> { return __builtin_llrintl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> long long>::__type
> llrint(_Tp __x)
> { return __builtin_llrint(__x); }
>
> constexpr long long
> llround(float __x)
> { return __builtin_llroundf(__x); }
>
> constexpr long long
> llround(long double __x)
> { return __builtin_llroundl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> long long>::__type
> llround(_Tp __x)
> { return __builtin_llround(__x); }
>
> constexpr float
> log1p(float __x)
> { return __builtin_log1pf(__x); }
>
> constexpr long double
> log1p(long double __x)
> { return __builtin_log1pl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> log1p(_Tp __x)
> { return __builtin_log1p(__x); }
>
>
> constexpr float
> log2(float __x)
> { return __builtin_log2f(__x); }
>
> constexpr long double
> log2(long double __x)
> { return __builtin_log2l(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> log2(_Tp __x)
> { return __builtin_log2(__x); }
>
> constexpr float
> logb(float __x)
> { return __builtin_logbf(__x); }
>
> constexpr long double
> logb(long double __x)
> { return __builtin_logbl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> logb(_Tp __x)
> { return __builtin_logb(__x); }
>
> constexpr long
> lrint(float __x)
> { return __builtin_lrintf(__x); }
>
> constexpr long
> lrint(long double __x)
> { return __builtin_lrintl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> long>::__type
> lrint(_Tp __x)
> { return __builtin_lrint(__x); }
>
> constexpr long
> lround(float __x)
> { return __builtin_lroundf(__x); }
>
> constexpr long
> lround(long double __x)
> { return __builtin_lroundl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> long>::__type
> lround(_Tp __x)
> { return __builtin_lround(__x); }
>
> constexpr float
> nearbyint(float __x)
> { return __builtin_nearbyintf(__x); }
>
> constexpr long double
> nearbyint(long double __x)
> { return __builtin_nearbyintl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> nearbyint(_Tp __x)
> { return __builtin_nearbyint(__x); }
>
> constexpr float
> nextafter(float __x, float __y)
> { return __builtin_nextafterf(__x, __y); }
>
> constexpr long double
> nextafter(long double __x, long double __y)
> { return __builtin_nextafterl(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr 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));
> }
>
> constexpr float
> nexttoward(float __x, long double __y)
> { return __builtin_nexttowardf(__x, __y); }
>
> constexpr long double
> nexttoward(long double __x, long double __y)
> { return __builtin_nexttowardl(__x, __y); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> nexttoward(_Tp __x, long double __y)
> { return __builtin_nexttoward(__x, __y); }
>
> constexpr float
> remainder(float __x, float __y)
> { return __builtin_remainderf(__x, __y); }
>
> constexpr long double
> remainder(long double __x, long double __y)
> { return __builtin_remainderl(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr 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);
> }
>
> constexpr float
> rint(float __x)
> { return __builtin_rintf(__x); }
>
> constexpr long double
> rint(long double __x)
> { return __builtin_rintl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> rint(_Tp __x)
> { return __builtin_rint(__x); }
>
> constexpr float
> round(float __x)
> { return __builtin_roundf(__x); }
>
> constexpr long double
> round(long double __x)
> { return __builtin_roundl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> round(_Tp __x)
> { return __builtin_round(__x); }
>
> constexpr float
> scalbln(float __x, long __ex)
> { return __builtin_scalblnf(__x, __ex); }
>
> constexpr long double
> scalbln(long double __x, long __ex)
> { return __builtin_scalblnl(__x, __ex); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> scalbln(_Tp __x, long __ex)
> { return __builtin_scalbln(__x, __ex); }
>
> constexpr float
> scalbn(float __x, int __ex)
> { return __builtin_scalbnf(__x, __ex); }
>
> constexpr long double
> scalbn(long double __x, int __ex)
> { return __builtin_scalbnl(__x, __ex); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> scalbn(_Tp __x, int __ex)
> { return __builtin_scalbn(__x, __ex); }
>
> constexpr float
> tgamma(float __x)
> { return __builtin_tgammaf(__x); }
>
> constexpr long double
> tgamma(long double __x)
> { return __builtin_tgammal(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> tgamma(_Tp __x)
> { return __builtin_tgamma(__x); }
>
> constexpr float
> trunc(float __x)
> { return __builtin_truncf(__x); }
>
> constexpr long double
> trunc(long double __x)
> { return __builtin_truncl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> trunc(_Tp __x)
> { return __builtin_trunc(__x); }
>
>
>}
># 45 "/usr/include/c++/4.8.2/complex" 2 3
># 1 "/usr/include/c++/4.8.2/sstream" 1 3
># 36 "/usr/include/c++/4.8.2/sstream" 3
> 
># 37 "/usr/include/c++/4.8.2/sstream" 3
>
># 1 "/usr/include/c++/4.8.2/istream" 1 3
># 36 "/usr/include/c++/4.8.2/istream" 3
> 
># 37 "/usr/include/c++/4.8.2/istream" 3
>
># 1 "/usr/include/c++/4.8.2/ios" 1 3
># 36 "/usr/include/c++/4.8.2/ios" 3
> 
># 37 "/usr/include/c++/4.8.2/ios" 3
>
># 1 "/usr/include/c++/4.8.2/iosfwd" 1 3
># 36 "/usr/include/c++/4.8.2/iosfwd" 3
> 
># 37 "/usr/include/c++/4.8.2/iosfwd" 3
>
>
># 1 "/usr/include/c++/4.8.2/bits/stringfwd.h" 1 3
># 37 "/usr/include/c++/4.8.2/bits/stringfwd.h" 3
> 
># 38 "/usr/include/c++/4.8.2/bits/stringfwd.h" 3
>
>
># 1 "/usr/include/c++/4.8.2/bits/memoryfwd.h" 1 3
># 46 "/usr/include/c++/4.8.2/bits/memoryfwd.h" 3
> 
># 47 "/usr/include/c++/4.8.2/bits/memoryfwd.h" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 63 "/usr/include/c++/4.8.2/bits/memoryfwd.h" 3
> template<typename>
> class allocator;
>
> template<>
> class allocator<void>;
>
>
> template<typename, typename>
> struct uses_allocator;
>
>
>
>
>}
># 41 "/usr/include/c++/4.8.2/bits/stringfwd.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>
> template<class _CharT>
> struct char_traits;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_string;
>
> template<> struct char_traits<char>;
>
>
> typedef basic_string<char> string;
>
>
> template<> struct char_traits<wchar_t>;
>
>
> typedef basic_string<wchar_t> wstring;
>
>
>
>
>
> template<> struct char_traits<char16_t>;
> template<> struct char_traits<char32_t>;
>
>
> typedef basic_string<char16_t> u16string;
>
>
> typedef basic_string<char32_t> u32string;
>
>
>
>
>
>}
># 40 "/usr/include/c++/4.8.2/iosfwd" 2 3
># 1 "/usr/include/c++/4.8.2/bits/postypes.h" 1 3
># 38 "/usr/include/c++/4.8.2/bits/postypes.h" 3
> 
># 39 "/usr/include/c++/4.8.2/bits/postypes.h" 3
>
># 1 "/usr/include/c++/4.8.2/cwchar" 1 3
># 39 "/usr/include/c++/4.8.2/cwchar" 3
> 
># 40 "/usr/include/c++/4.8.2/cwchar" 3
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 36 "/usr/include/wchar.h" 3 4
># 1 "/usr/include/stdio.h" 1 3 4
># 44 "/usr/include/stdio.h" 3 4
>struct _IO_FILE;
>
>
>
>typedef struct _IO_FILE FILE;
>
>
>
>
>
># 64 "/usr/include/stdio.h" 3 4
>typedef struct _IO_FILE __FILE;
># 37 "/usr/include/wchar.h" 2 3 4
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stdarg.h" 1 3 4
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 40 "/usr/include/wchar.h" 2 3 4
>
># 1 "/usr/include/bits/wchar.h" 1 3 4
># 42 "/usr/include/wchar.h" 2 3 4
># 51 "/usr/include/wchar.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 212 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 3 4
>typedef long unsigned int size_t;
># 353 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 3 4
>typedef unsigned int wint_t;
># 52 "/usr/include/wchar.h" 2 3 4
># 82 "/usr/include/wchar.h" 3 4
>typedef struct
>{
> int __count;
> union
> {
>
> unsigned int __wch;
>
>
>
> char __wchb[4];
> } __value;
>} __mbstate_t;
># 104 "/usr/include/wchar.h" 3 4
>
>
>typedef __mbstate_t mbstate_t;
>
>
>
>
>
>
># 132 "/usr/include/wchar.h" 3 4
>extern "C" {
>
>
>
>
>struct tm;
>
>
>
>
>
>
>
>
>
>extern wchar_t *wcscpy (wchar_t *__restrict __dest,
> const wchar_t *__restrict __src) throw ();
>
>extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
> const wchar_t *__restrict __src, size_t __n)
> throw ();
>
>
>extern wchar_t *wcscat (wchar_t *__restrict __dest,
> const wchar_t *__restrict __src) throw ();
>
>extern wchar_t *wcsncat (wchar_t *__restrict __dest,
> const wchar_t *__restrict __src, size_t __n)
> throw ();
>
>
>extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
> throw () __attribute__ ((__pure__));
>
>extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
> throw () __attribute__ ((__pure__));
>
>
>
>
>extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
>
>
>extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
> size_t __n) throw ();
>
>
>
># 1 "/usr/include/xlocale.h" 1 3 4
># 27 "/usr/include/xlocale.h" 3 4
>typedef struct __locale_struct
>{
>
> struct __locale_data *__locales[13];
>
>
> const unsigned short int *__ctype_b;
> const int *__ctype_tolower;
> const int *__ctype_toupper;
>
>
> const char *__names[13];
>} *__locale_t;
>
>
>typedef __locale_t locale_t;
># 181 "/usr/include/wchar.h" 2 3 4
>
>extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
> __locale_t __loc) throw ();
>
>extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
> size_t __n, __locale_t __loc) throw ();
>
>
>
>
>
>extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
>
>
>
>extern size_t wcsxfrm (wchar_t *__restrict __s1,
> const wchar_t *__restrict __s2, size_t __n) throw ();
>
>
>
>
>
>
>
>
>extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
> __locale_t __loc) throw ();
>
>
>
>
>extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
> size_t __n, __locale_t __loc) throw ();
>
>
>extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
>
>
>
>
>
>extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
> throw () __asm ("wcschr") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
> throw () __asm ("wcschr") __attribute__ ((__pure__));
>
>
>
>
>
>
>extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
> throw () __asm ("wcsrchr") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
> throw () __asm ("wcsrchr") __attribute__ ((__pure__));
>
>
>
>
>
>
>
>
>
>extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
> throw () __attribute__ ((__pure__));
>
>
>
>
>
>extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
> throw () __attribute__ ((__pure__));
>
>
>extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
> throw () __attribute__ ((__pure__));
>
>
>extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept)
> throw () __asm ("wcspbrk") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
> const wchar_t *__accept)
> throw () __asm ("wcspbrk") __attribute__ ((__pure__));
>
>
>
>
>
>
>extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle)
> throw () __asm ("wcsstr") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
> const wchar_t *__needle)
> throw () __asm ("wcsstr") __attribute__ ((__pure__));
>
>
>
>
>
>
>extern wchar_t *wcstok (wchar_t *__restrict __s,
> const wchar_t *__restrict __delim,
> wchar_t **__restrict __ptr) throw ();
>
>
>extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
>
>
>
>
>
>extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle)
> throw () __asm ("wcswcs") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack,
> const wchar_t *__needle)
> throw () __asm ("wcswcs") __attribute__ ((__pure__));
># 306 "/usr/include/wchar.h" 3 4
>extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
> throw () __attribute__ ((__pure__));
>
>
>
>
>
>
>extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
> throw () __asm ("wmemchr") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
> size_t __n)
> throw () __asm ("wmemchr") __attribute__ ((__pure__));
>
>
>
>
>
>
>extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
> throw () __attribute__ ((__pure__));
>
>
>extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
> const wchar_t *__restrict __s2, size_t __n) throw ();
>
>
>
>extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
> throw ();
>
>
>extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
>
>
>
>
>
>extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
> const wchar_t *__restrict __s2, size_t __n)
> throw ();
>
>
>
>
>
>
>extern wint_t btowc (int __c) throw ();
>
>
>
>extern int wctob (wint_t __c) throw ();
>
>
>
>extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
>
>
>
>extern size_t mbrtowc (wchar_t *__restrict __pwc,
> const char *__restrict __s, size_t __n,
> mbstate_t *__restrict __p) throw ();
>
>
>extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
> mbstate_t *__restrict __ps) throw ();
>
>
>extern size_t __mbrlen (const char *__restrict __s, size_t __n,
> mbstate_t *__restrict __ps) throw ();
>extern size_t mbrlen (const char *__restrict __s, size_t __n,
> mbstate_t *__restrict __ps) throw ();
>
>
>
>
>
>
>
>
>extern wint_t __btowc_alias (int __c) __asm ("btowc");
>extern __inline __attribute__ ((__gnu_inline__)) wint_t
>__attribute__ ((__leaf__)) btowc (int __c) throw ()
>{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f'
> ? (wint_t) __c : __btowc_alias (__c)); }
>
>extern int __wctob_alias (wint_t __c) __asm ("wctob");
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) wctob (wint_t __wc) throw ()
>{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f'
> ? (int) __wc : __wctob_alias (__wc)); }
>
>extern __inline __attribute__ ((__gnu_inline__)) size_t
>__attribute__ ((__leaf__)) mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw ()
>
>{ return (__ps != __null
> ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); }
>
>
>
>
>
>extern size_t mbsrtowcs (wchar_t *__restrict __dst,
> const char **__restrict __src, size_t __len,
> mbstate_t *__restrict __ps) throw ();
>
>
>
>extern size_t wcsrtombs (char *__restrict __dst,
> const wchar_t **__restrict __src, size_t __len,
> mbstate_t *__restrict __ps) throw ();
>
>
>
>
>
>
>extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
> const char **__restrict __src, size_t __nmc,
> size_t __len, mbstate_t *__restrict __ps) throw ();
>
>
>
>extern size_t wcsnrtombs (char *__restrict __dst,
> const wchar_t **__restrict __src,
> size_t __nwc, size_t __len,
> mbstate_t *__restrict __ps) throw ();
>
>
>
>
>
>
>extern int wcwidth (wchar_t __c) throw ();
>
>
>
>extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
>
>
>
>
>
>
>extern double wcstod (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr) throw ();
>
>
>
>
>
>extern float wcstof (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr) throw ();
>extern long double wcstold (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr) throw ();
>
>
>
>
>
>
>
>extern long int wcstol (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base) throw ();
>
>
>
>extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base)
> throw ();
>
>
>
>
>
>
>__extension__
>extern long long int wcstoll (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base)
> throw ();
>
>
>
>__extension__
>extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base) throw ();
>
>
>
>
>
>
>__extension__
>extern long long int wcstoq (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base)
> throw ();
>
>
>
>__extension__
>extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base) throw ();
># 530 "/usr/include/wchar.h" 3 4
>extern long int wcstol_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base,
> __locale_t __loc) throw ();
>
>extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base, __locale_t __loc) throw ();
>
>__extension__
>extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base, __locale_t __loc) throw ();
>
>__extension__
>extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base, __locale_t __loc)
> throw ();
>
>extern double wcstod_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, __locale_t __loc)
> throw ();
>
>extern float wcstof_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, __locale_t __loc)
> throw ();
>
>extern long double wcstold_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> __locale_t __loc) throw ();
>
>
>
>
>
>
>extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
> const wchar_t *__restrict __src) throw ();
>
>
>
>extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
> const wchar_t *__restrict __src, size_t __n)
> throw ();
>
>
>
>
>
>
>extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
>
>
>
>
>
>
>extern int fwide (__FILE *__fp, int __mode) throw ();
>
>
>
>
>
>
>extern int fwprintf (__FILE *__restrict __stream,
> const wchar_t *__restrict __format, ...)
> ;
>
>
>
>
>extern int wprintf (const wchar_t *__restrict __format, ...)
> ;
>
>extern int swprintf (wchar_t *__restrict __s, size_t __n,
> const wchar_t *__restrict __format, ...)
> throw () ;
>
>
>
>
>
>extern int vfwprintf (__FILE *__restrict __s,
> const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> ;
>
>
>
>
>extern int vwprintf (const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> ;
>
>
>extern int vswprintf (wchar_t *__restrict __s, size_t __n,
> const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> throw () ;
>
>
>
>
>
>
>extern int fwscanf (__FILE *__restrict __stream,
> const wchar_t *__restrict __format, ...)
> ;
>
>
>
>
>extern int wscanf (const wchar_t *__restrict __format, ...)
> ;
>
>extern int swscanf (const wchar_t *__restrict __s,
> const wchar_t *__restrict __format, ...)
> throw () ;
># 680 "/usr/include/wchar.h" 3 4
>
>
>
>
>
>
>
>
>
>extern int vfwscanf (__FILE *__restrict __s,
> const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> ;
>
>
>
>
>extern int vwscanf (const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> ;
>
>extern int vswscanf (const wchar_t *__restrict __s,
> const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> throw () ;
># 736 "/usr/include/wchar.h" 3 4
>
>
>
>
>
>
>
>
>
>extern wint_t fgetwc (__FILE *__stream);
>extern wint_t getwc (__FILE *__stream);
>
>
>
>
>
>extern wint_t getwchar (void);
>
>
>
>
>
>
>extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
>extern wint_t putwc (wchar_t __wc, __FILE *__stream);
>
>
>
>
>
>extern wint_t putwchar (wchar_t __wc);
>
>
>
>
>
>
>
>extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
> __FILE *__restrict __stream);
>
>
>
>
>
>extern int fputws (const wchar_t *__restrict __ws,
> __FILE *__restrict __stream);
>
>
>
>
>
>
>extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
>
># 801 "/usr/include/wchar.h" 3 4
>extern wint_t getwc_unlocked (__FILE *__stream);
>extern wint_t getwchar_unlocked (void);
>
>
>
>
>
>
>
>extern wint_t fgetwc_unlocked (__FILE *__stream);
>
>
>
>
>
>
>
>extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
># 827 "/usr/include/wchar.h" 3 4
>extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
>extern wint_t putwchar_unlocked (wchar_t __wc);
># 837 "/usr/include/wchar.h" 3 4
>extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
> __FILE *__restrict __stream);
>
>
>
>
>
>
>
>extern int fputws_unlocked (const wchar_t *__restrict __ws,
> __FILE *__restrict __stream);
>
>
>
>
>
>
>
>extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
> const wchar_t *__restrict __format,
> const struct tm *__restrict __tp) throw ();
>
>
>
>
>
>
>
>extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
> const wchar_t *__restrict __format,
> const struct tm *__restrict __tp,
> __locale_t __loc) throw ();
># 891 "/usr/include/wchar.h" 3 4
>}
># 45 "/usr/include/c++/4.8.2/cwchar" 2 3
># 62 "/usr/include/c++/4.8.2/cwchar" 3
>namespace std
>{
> using ::mbstate_t;
>}
># 135 "/usr/include/c++/4.8.2/cwchar" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> using ::wint_t;
>
> using ::btowc;
> using ::fgetwc;
> using ::fgetws;
> using ::fputwc;
> using ::fputws;
> using ::fwide;
> using ::fwprintf;
> using ::fwscanf;
> using ::getwc;
> using ::getwchar;
> using ::mbrlen;
> using ::mbrtowc;
> using ::mbsinit;
> using ::mbsrtowcs;
> using ::putwc;
> using ::putwchar;
>
> using ::swprintf;
>
> using ::swscanf;
> using ::ungetwc;
> using ::vfwprintf;
>
> using ::vfwscanf;
>
>
> using ::vswprintf;
>
>
> using ::vswscanf;
>
> using ::vwprintf;
>
> using ::vwscanf;
>
> using ::wcrtomb;
> using ::wcscat;
> using ::wcscmp;
> using ::wcscoll;
> using ::wcscpy;
> using ::wcscspn;
> using ::wcsftime;
> using ::wcslen;
> using ::wcsncat;
> using ::wcsncmp;
> using ::wcsncpy;
> using ::wcsrtombs;
> using ::wcsspn;
> using ::wcstod;
>
> using ::wcstof;
>
> using ::wcstok;
> using ::wcstol;
> using ::wcstoul;
> using ::wcsxfrm;
> using ::wctob;
> using ::wmemcmp;
> using ::wmemcpy;
> using ::wmemmove;
> using ::wmemset;
> using ::wprintf;
> using ::wscanf;
> using ::wcschr;
> using ::wcspbrk;
> using ::wcsrchr;
> using ::wcsstr;
> using ::wmemchr;
># 232 "/usr/include/c++/4.8.2/cwchar" 3
>
>}
>
>
>
>
>
>
>
>namespace __gnu_cxx
>{
>
>
>
>
>
> using ::wcstold;
># 257 "/usr/include/c++/4.8.2/cwchar" 3
> using ::wcstoll;
> using ::wcstoull;
>
>}
>
>namespace std
>{
> using ::__gnu_cxx::wcstold;
> using ::__gnu_cxx::wcstoll;
> using ::__gnu_cxx::wcstoull;
>}
># 277 "/usr/include/c++/4.8.2/cwchar" 3
>namespace std
>{
>
> using std::wcstof;
>
>
> using std::vfwscanf;
>
>
> using std::vswscanf;
>
>
> using std::vwscanf;
>
>
>
> using std::wcstold;
> using std::wcstoll;
> using std::wcstoull;
>
>}
># 41 "/usr/include/c++/4.8.2/bits/postypes.h" 2 3
># 68 "/usr/include/c++/4.8.2/bits/postypes.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 88 "/usr/include/c++/4.8.2/bits/postypes.h" 3
> typedef long streamoff;
># 98 "/usr/include/c++/4.8.2/bits/postypes.h" 3
> typedef ptrdiff_t streamsize;
># 111 "/usr/include/c++/4.8.2/bits/postypes.h" 3
> template<typename _StateT>
> class fpos
> {
> private:
> streamoff _M_off;
> _StateT _M_state;
>
> public:
>
>
>
>
> fpos()
> : _M_off(0), _M_state() { }
># 133 "/usr/include/c++/4.8.2/bits/postypes.h" 3
> fpos(streamoff __off)
> : _M_off(__off), _M_state() { }
>
>
> operator streamoff() const { return _M_off; }
>
>
> void
> state(_StateT __st)
> { _M_state = __st; }
>
>
> _StateT
> state() const
> { return _M_state; }
>
>
>
>
>
> fpos&
> operator+=(streamoff __off)
> {
> _M_off += __off;
> return *this;
> }
>
>
>
>
>
> fpos&
> operator-=(streamoff __off)
> {
> _M_off -= __off;
> return *this;
> }
>
>
>
>
>
>
>
> fpos
> operator+(streamoff __off) const
> {
> fpos __pos(*this);
> __pos += __off;
> return __pos;
> }
>
>
>
>
>
>
>
> fpos
> operator-(streamoff __off) const
> {
> fpos __pos(*this);
> __pos -= __off;
> return __pos;
> }
>
>
>
>
>
>
> streamoff
> operator-(const fpos& __other) const
> { return _M_off - __other._M_off; }
> };
>
>
>
>
>
>
> template<typename _StateT>
> inline bool
> operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
> { return streamoff(__lhs) == streamoff(__rhs); }
>
> template<typename _StateT>
> inline bool
> operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
> { return streamoff(__lhs) != streamoff(__rhs); }
>
>
>
>
>
> typedef fpos<mbstate_t> streampos;
>
> typedef fpos<mbstate_t> wstreampos;
>
>
>
> typedef fpos<mbstate_t> u16streampos;
>
> typedef fpos<mbstate_t> u32streampos;
>
>
>
>}
># 41 "/usr/include/c++/4.8.2/iosfwd" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 74 "/usr/include/c++/4.8.2/iosfwd" 3
> class ios_base;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_ios;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_streambuf;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_istream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_ostream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_iostream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_stringbuf;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_istringstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_ostringstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_stringstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_filebuf;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_ifstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_ofstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_fstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class istreambuf_iterator;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class ostreambuf_iterator;
>
>
>
> typedef basic_ios<char> ios;
>
>
> typedef basic_streambuf<char> streambuf;
>
>
> typedef basic_istream<char> istream;
>
>
> typedef basic_ostream<char> ostream;
>
>
> typedef basic_iostream<char> iostream;
>
>
> typedef basic_stringbuf<char> stringbuf;
>
>
> typedef basic_istringstream<char> istringstream;
>
>
> typedef basic_ostringstream<char> ostringstream;
>
>
> typedef basic_stringstream<char> stringstream;
>
>
> typedef basic_filebuf<char> filebuf;
>
>
> typedef basic_ifstream<char> ifstream;
>
>
> typedef basic_ofstream<char> ofstream;
>
>
> typedef basic_fstream<char> fstream;
>
>
>
> typedef basic_ios<wchar_t> wios;
>
>
> typedef basic_streambuf<wchar_t> wstreambuf;
>
>
> typedef basic_istream<wchar_t> wistream;
>
>
> typedef basic_ostream<wchar_t> wostream;
>
>
> typedef basic_iostream<wchar_t> wiostream;
>
>
> typedef basic_stringbuf<wchar_t> wstringbuf;
>
>
> typedef basic_istringstream<wchar_t> wistringstream;
>
>
> typedef basic_ostringstream<wchar_t> wostringstream;
>
>
> typedef basic_stringstream<wchar_t> wstringstream;
>
>
> typedef basic_filebuf<wchar_t> wfilebuf;
>
>
> typedef basic_ifstream<wchar_t> wifstream;
>
>
> typedef basic_ofstream<wchar_t> wofstream;
>
>
> typedef basic_fstream<wchar_t> wfstream;
>
>
>
>
>}
># 39 "/usr/include/c++/4.8.2/ios" 2 3
># 1 "/usr/include/c++/4.8.2/exception" 1 3
># 33 "/usr/include/c++/4.8.2/exception" 3
> 
># 34 "/usr/include/c++/4.8.2/exception" 3
>
>#pragma GCC visibility push(default)
>
>
># 1 "/usr/include/c++/4.8.2/bits/atomic_lockfree_defines.h" 1 3
># 33 "/usr/include/c++/4.8.2/bits/atomic_lockfree_defines.h" 3
> 
># 34 "/usr/include/c++/4.8.2/bits/atomic_lockfree_defines.h" 3
># 39 "/usr/include/c++/4.8.2/exception" 2 3
>
>extern "C++" {
>
>namespace std
>{
># 60 "/usr/include/c++/4.8.2/exception" 3
> class exception
> {
> public:
> exception() noexcept { }
> virtual ~exception() noexcept;
>
>
>
> virtual const char* what() const noexcept;
> };
>
>
>
> class bad_exception : public exception
> {
> public:
> bad_exception() noexcept { }
>
>
>
> virtual ~bad_exception() noexcept;
>
>
> virtual const char* what() const noexcept;
> };
>
>
> typedef void (*terminate_handler) ();
>
>
> typedef void (*unexpected_handler) ();
>
>
> terminate_handler set_terminate(terminate_handler) noexcept;
>
>
>
> void terminate() noexcept __attribute__ ((__noreturn__));
>
>
> unexpected_handler set_unexpected(unexpected_handler) noexcept;
>
>
>
> void unexpected() __attribute__ ((__noreturn__));
># 117 "/usr/include/c++/4.8.2/exception" 3
> bool uncaught_exception() noexcept __attribute__ ((__pure__));
>
>
>}
>
>namespace __gnu_cxx
>{
>
># 142 "/usr/include/c++/4.8.2/exception" 3
> void __verbose_terminate_handler();
>
>
>}
>
>}
>
>#pragma GCC visibility pop
>
>
># 1 "/usr/include/c++/4.8.2/bits/exception_ptr.h" 1 3
># 34 "/usr/include/c++/4.8.2/bits/exception_ptr.h" 3
>#pragma GCC visibility push(default)
>
>
># 1 "/usr/include/c++/4.8.2/bits/exception_defines.h" 1 3
># 38 "/usr/include/c++/4.8.2/bits/exception_ptr.h" 2 3
>
>
>
>
>
>extern "C++" {
>
>namespace std
>{
> class type_info;
>
>
>
>
>
> namespace __exception_ptr
> {
> class exception_ptr;
> }
>
> using __exception_ptr::exception_ptr;
>
>
>
>
>
> exception_ptr current_exception() noexcept;
>
>
> void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
>
> namespace __exception_ptr
> {
>
>
>
>
> class exception_ptr
> {
> void* _M_exception_object;
>
> explicit exception_ptr(void* __e) noexcept;
>
> void _M_addref() noexcept;
> void _M_release() noexcept;
>
> void *_M_get() const noexcept __attribute__ ((__pure__));
>
> friend exception_ptr std::current_exception() noexcept;
> friend void std::rethrow_exception(exception_ptr);
>
> public:
> exception_ptr() noexcept;
>
> exception_ptr(const exception_ptr&) noexcept;
>
>
> exception_ptr(nullptr_t) noexcept
> : _M_exception_object(0)
> { }
>
> exception_ptr(exception_ptr&& __o) noexcept
> : _M_exception_object(__o._M_exception_object)
> { __o._M_exception_object = 0; }
># 111 "/usr/include/c++/4.8.2/bits/exception_ptr.h" 3
> exception_ptr&
> operator=(const exception_ptr&) noexcept;
>
>
> exception_ptr&
> operator=(exception_ptr&& __o) noexcept
> {
> exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
> return *this;
> }
>
>
> ~exception_ptr() noexcept;
>
> void
> swap(exception_ptr&) noexcept;
># 138 "/usr/include/c++/4.8.2/bits/exception_ptr.h" 3
> explicit operator bool() const
> { return _M_exception_object; }
>
>
> friend bool
> operator==(const exception_ptr&, const exception_ptr&)
> noexcept __attribute__ ((__pure__));
>
> const class std::type_info*
> __cxa_exception_type() const noexcept
> __attribute__ ((__pure__));
> };
>
> bool
> operator==(const exception_ptr&, const exception_ptr&)
> noexcept __attribute__ ((__pure__));
>
> bool
> operator!=(const exception_ptr&, const exception_ptr&)
> noexcept __attribute__ ((__pure__));
>
> inline void
> swap(exception_ptr& __lhs, exception_ptr& __rhs)
> { __lhs.swap(__rhs); }
>
> }
>
>
>
> template<typename _Ex>
> exception_ptr
> copy_exception(_Ex __ex) noexcept
> {
> try
> {
>
> throw __ex;
>
> }
> catch(...)
> {
> return current_exception();
> }
> }
>
>
>
>
> template<typename _Ex>
> exception_ptr
> make_exception_ptr(_Ex __ex) noexcept
> { return std::copy_exception<_Ex>(__ex); }
>
>
>}
>
>}
>
>#pragma GCC visibility pop
># 153 "/usr/include/c++/4.8.2/exception" 2 3
># 1 "/usr/include/c++/4.8.2/bits/nested_exception.h" 1 3
># 33 "/usr/include/c++/4.8.2/bits/nested_exception.h" 3
>#pragma GCC visibility push(default)
># 45 "/usr/include/c++/4.8.2/bits/nested_exception.h" 3
>extern "C++" {
>
>namespace std
>{
>
>
>
>
>
>
> class nested_exception
> {
> exception_ptr _M_ptr;
>
> public:
> nested_exception() noexcept : _M_ptr(current_exception()) { }
>
> nested_exception(const nested_exception&) = default;
>
> nested_exception& operator=(const nested_exception&) = default;
>
> virtual ~nested_exception() noexcept;
>
> void
> rethrow_nested() const __attribute__ ((__noreturn__))
> { rethrow_exception(_M_ptr); }
>
> exception_ptr
> nested_ptr() const
> { return _M_ptr; }
> };
>
> template<typename _Except>
> struct _Nested_exception : public _Except, public nested_exception
> {
> explicit _Nested_exception(_Except&& __ex)
> : _Except(static_cast<_Except&&>(__ex))
> { }
> };
>
> template<typename _Ex>
> struct __get_nested_helper
> {
> static const nested_exception*
> _S_get(const _Ex& __ex)
> { return dynamic_cast<const nested_exception*>(&__ex); }
> };
>
> template<typename _Ex>
> struct __get_nested_helper<_Ex*>
> {
> static const nested_exception*
> _S_get(const _Ex* __ex)
> { return dynamic_cast<const nested_exception*>(__ex); }
> };
>
> template<typename _Ex>
> inline const nested_exception*
> __get_nested_exception(const _Ex& __ex)
> { return __get_nested_helper<_Ex>::_S_get(__ex); }
>
> template<typename _Ex>
> void
> __throw_with_nested(_Ex&&, const nested_exception* = 0)
> __attribute__ ((__noreturn__));
>
> template<typename _Ex>
> void
> __throw_with_nested(_Ex&&, ...) __attribute__ ((__noreturn__));
>
>
>
>
> template<typename _Ex>
> inline void
> __throw_with_nested(_Ex&& __ex, const nested_exception*)
> { throw __ex; }
>
> template<typename _Ex>
> inline void
> __throw_with_nested(_Ex&& __ex, ...)
> { throw _Nested_exception<_Ex>(static_cast<_Ex&&>(__ex)); }
>
> template<typename _Ex>
> void
> throw_with_nested(_Ex __ex) __attribute__ ((__noreturn__));
>
>
>
> template<typename _Ex>
> inline void
> throw_with_nested(_Ex __ex)
> {
> if (__get_nested_exception(__ex))
> throw __ex;
> __throw_with_nested(static_cast<_Ex&&>(__ex), &__ex);
> }
>
>
> template<typename _Ex>
> inline void
> rethrow_if_nested(const _Ex& __ex)
> {
> if (const nested_exception* __nested = __get_nested_exception(__ex))
> __nested->rethrow_nested();
> }
>
>
> inline void
> rethrow_if_nested(const nested_exception& __ex)
> { __ex.rethrow_nested(); }
>
>
>}
>
>}
>
>
>
>#pragma GCC visibility pop
># 154 "/usr/include/c++/4.8.2/exception" 2 3
># 40 "/usr/include/c++/4.8.2/ios" 2 3
># 1 "/usr/include/c++/4.8.2/bits/char_traits.h" 1 3
># 37 "/usr/include/c++/4.8.2/bits/char_traits.h" 3
> 
># 38 "/usr/include/c++/4.8.2/bits/char_traits.h" 3
>
># 1 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 1 3
># 60 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
># 1 "/usr/include/c++/4.8.2/bits/functexcept.h" 1 3
># 42 "/usr/include/c++/4.8.2/bits/functexcept.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> void
> __throw_bad_exception(void) __attribute__((__noreturn__));
>
>
> void
> __throw_bad_alloc(void) __attribute__((__noreturn__));
>
>
> void
> __throw_bad_cast(void) __attribute__((__noreturn__));
>
> void
> __throw_bad_typeid(void) __attribute__((__noreturn__));
>
>
> void
> __throw_logic_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_domain_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_invalid_argument(const char*) __attribute__((__noreturn__));
>
> void
> __throw_length_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_out_of_range(const char*) __attribute__((__noreturn__));
>
> void
> __throw_runtime_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_range_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_overflow_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_underflow_error(const char*) __attribute__((__noreturn__));
>
>
> void
> __throw_ios_failure(const char*) __attribute__((__noreturn__));
>
> void
> __throw_system_error(int) __attribute__((__noreturn__));
>
> void
> __throw_future_error(int) __attribute__((__noreturn__));
>
>
> void
> __throw_bad_function_call() __attribute__((__noreturn__));
>
>
>}
># 61 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 2 3
>
>
># 1 "/usr/include/c++/4.8.2/ext/numeric_traits.h" 1 3
># 32 "/usr/include/c++/4.8.2/ext/numeric_traits.h" 3
> 
># 33 "/usr/include/c++/4.8.2/ext/numeric_traits.h" 3
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
># 54 "/usr/include/c++/4.8.2/ext/numeric_traits.h" 3
> template<typename _Value>
> struct __numeric_traits_integer
> {
>
> static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
> static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);
>
>
>
> static const bool __is_signed = ((_Value)(-1) < 0);
> static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
> };
>
> template<typename _Value>
> const _Value __numeric_traits_integer<_Value>::__min;
>
> template<typename _Value>
> const _Value __numeric_traits_integer<_Value>::__max;
>
> template<typename _Value>
> const bool __numeric_traits_integer<_Value>::__is_signed;
>
> template<typename _Value>
> const int __numeric_traits_integer<_Value>::__digits;
># 99 "/usr/include/c++/4.8.2/ext/numeric_traits.h" 3
> template<typename _Value>
> struct __numeric_traits_floating
> {
>
> static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);
>
>
> static const bool __is_signed = true;
> static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
> static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
> };
>
> template<typename _Value>
> const int __numeric_traits_floating<_Value>::__max_digits10;
>
> template<typename _Value>
> const bool __numeric_traits_floating<_Value>::__is_signed;
>
> template<typename _Value>
> const int __numeric_traits_floating<_Value>::__digits10;
>
> template<typename _Value>
> const int __numeric_traits_floating<_Value>::__max_exponent10;
>
> template<typename _Value>
> struct __numeric_traits
> : public __conditional_type<std::__is_integer<_Value>::__value,
> __numeric_traits_integer<_Value>,
> __numeric_traits_floating<_Value> >::__type
> { };
>
>
>}
># 64 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/4.8.2/bits/stl_pair.h" 1 3
># 59 "/usr/include/c++/4.8.2/bits/stl_pair.h" 3
># 1 "/usr/include/c++/4.8.2/bits/move.h" 1 3
># 34 "/usr/include/c++/4.8.2/bits/move.h" 3
># 1 "/usr/include/c++/4.8.2/bits/concept_check.h" 1 3
># 33 "/usr/include/c++/4.8.2/bits/concept_check.h" 3
> 
># 34 "/usr/include/c++/4.8.2/bits/concept_check.h" 3
># 35 "/usr/include/c++/4.8.2/bits/move.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> template<typename _Tp>
> inline _Tp*
> __addressof(_Tp& __r) noexcept
> {
> return reinterpret_cast<_Tp*>
> (&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
> }
>
>
>}
>
>
># 1 "/usr/include/c++/4.8.2/type_traits" 1 3
># 32 "/usr/include/c++/4.8.2/type_traits" 3
> 
># 33 "/usr/include/c++/4.8.2/type_traits" 3
>
>
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 56 "/usr/include/c++/4.8.2/type_traits" 3
> template<typename _Tp, _Tp __v>
> struct integral_constant
> {
> static constexpr _Tp value = __v;
> typedef _Tp value_type;
> typedef integral_constant<_Tp, __v> type;
> constexpr operator value_type() { return value; }
> };
>
> template<typename _Tp, _Tp __v>
> constexpr _Tp integral_constant<_Tp, __v>::value;
>
>
> typedef integral_constant<bool, true> true_type;
>
>
> typedef integral_constant<bool, false> false_type;
>
>
>
> template<bool, typename, typename>
> struct conditional;
>
> template<typename...>
> struct __or_;
>
> template<>
> struct __or_<>
> : public false_type
> { };
>
> template<typename _B1>
> struct __or_<_B1>
> : public _B1
> { };
>
> template<typename _B1, typename _B2>
> struct __or_<_B1, _B2>
> : public conditional<_B1::value, _B1, _B2>::type
> { };
>
> template<typename _B1, typename _B2, typename _B3, typename... _Bn>
> struct __or_<_B1, _B2, _B3, _Bn...>
> : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
> { };
>
> template<typename...>
> struct __and_;
>
> template<>
> struct __and_<>
> : public true_type
> { };
>
> template<typename _B1>
> struct __and_<_B1>
> : public _B1
> { };
>
> template<typename _B1, typename _B2>
> struct __and_<_B1, _B2>
> : public conditional<_B1::value, _B2, _B1>::type
> { };
>
> template<typename _B1, typename _B2, typename _B3, typename... _Bn>
> struct __and_<_B1, _B2, _B3, _Bn...>
> : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
> { };
>
> template<typename _Pp>
> struct __not_
> : public integral_constant<bool, !_Pp::value>
> { };
>
> struct __sfinae_types
> {
> typedef char __one;
> typedef struct { char __arr[2]; } __two;
> };
>
>
>
>
>
>
> template<typename _Tp>
> struct __success_type
> { typedef _Tp type; };
>
> struct __failure_type
> { };
>
>
>
> template<typename>
> struct remove_cv;
>
> template<typename>
> struct __is_void_helper
> : public false_type { };
>
> template<>
> struct __is_void_helper<void>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_void
> : public integral_constant<bool, (__is_void_helper<typename
> remove_cv<_Tp>::type>::value)>
> { };
>
> template<typename>
> struct __is_integral_helper
> : public false_type { };
>
> template<>
> struct __is_integral_helper<bool>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<char>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<signed char>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned char>
> : public true_type { };
>
>
> template<>
> struct __is_integral_helper<wchar_t>
> : public true_type { };
>
>
> template<>
> struct __is_integral_helper<char16_t>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<char32_t>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<short>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned short>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<int>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned int>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<long>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned long>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<long long>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned long long>
> : public true_type { };
># 245 "/usr/include/c++/4.8.2/type_traits" 3
> template<typename _Tp>
> struct is_integral
> : public integral_constant<bool, (__is_integral_helper<typename
> remove_cv<_Tp>::type>::value)>
> { };
>
> template<typename>
> struct __is_floating_point_helper
> : public false_type { };
>
> template<>
> struct __is_floating_point_helper<float>
> : public true_type { };
>
> template<>
> struct __is_floating_point_helper<double>
> : public true_type { };
>
> template<>
> struct __is_floating_point_helper<long double>
> : public true_type { };
># 274 "/usr/include/c++/4.8.2/type_traits" 3
> template<typename _Tp>
> struct is_floating_point
> : public integral_constant<bool, (__is_floating_point_helper<typename
> remove_cv<_Tp>::type>::value)>
> { };
>
>
> 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_helper
> : public false_type { };
>
> template<typename _Tp>
> struct __is_pointer_helper<_Tp*>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_pointer
> : public integral_constant<bool, (__is_pointer_helper<typename
> remove_cv<_Tp>::type>::value)>
> { };
>
>
> template<typename>
> struct is_lvalue_reference
> : public false_type { };
>
> template<typename _Tp>
> struct is_lvalue_reference<_Tp&>
> : public true_type { };
>
>
> template<typename>
> struct is_rvalue_reference
> : public false_type { };
>
> template<typename _Tp>
> struct is_rvalue_reference<_Tp&&>
> : public true_type { };
>
> template<typename>
> struct is_function;
>
> template<typename>
> struct __is_member_object_pointer_helper
> : public false_type { };
>
> template<typename _Tp, typename _Cp>
> struct __is_member_object_pointer_helper<_Tp _Cp::*>
> : public integral_constant<bool, !is_function<_Tp>::value> { };
>
>
> template<typename _Tp>
> struct is_member_object_pointer
> : public integral_constant<bool, (__is_member_object_pointer_helper<
> typename remove_cv<_Tp>::type>::value)>
> { };
>
> template<typename>
> struct __is_member_function_pointer_helper
> : public false_type { };
>
> template<typename _Tp, typename _Cp>
> struct __is_member_function_pointer_helper<_Tp _Cp::*>
> : public integral_constant<bool, is_function<_Tp>::value> { };
>
>
> template<typename _Tp>
> struct is_member_function_pointer
> : public integral_constant<bool, (__is_member_function_pointer_helper<
> typename remove_cv<_Tp>::type>::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
> : public false_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes...)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes......)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes...) const>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes......) const>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes...) volatile>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes......) volatile>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes...) const volatile>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes......) const volatile>
> : public true_type { };
>
> template<typename>
> struct __is_nullptr_t_helper
> : public false_type { };
>
> template<>
> struct __is_nullptr_t_helper<std::nullptr_t>
> : public true_type { };
>
>
> template<typename _Tp>
> struct __is_nullptr_t
> : public integral_constant<bool, (__is_nullptr_t_helper<typename
> remove_cv<_Tp>::type>::value)>
> { };
>
>
>
>
> template<typename _Tp>
> struct is_reference
> : public __or_<is_lvalue_reference<_Tp>,
> is_rvalue_reference<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_arithmetic
> : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_fundamental
> : public __or_<is_arithmetic<_Tp>, is_void<_Tp>, __is_nullptr_t<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_object
> : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
> is_void<_Tp>>>::type
> { };
>
> template<typename>
> struct is_member_pointer;
>
>
> template<typename _Tp>
> struct is_scalar
> : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
> is_member_pointer<_Tp>, __is_nullptr_t<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_compound
> : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
>
> template<typename _Tp>
> struct __is_member_pointer_helper
> : public false_type { };
>
> template<typename _Tp, typename _Cp>
> struct __is_member_pointer_helper<_Tp _Cp::*>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_member_pointer
> : public integral_constant<bool, (__is_member_pointer_helper<
> typename remove_cv<_Tp>::type>::value)>
> { };
>
>
>
>
> 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_trivial
> : public integral_constant<bool, __is_trivial(_Tp)>
> { };
>
>
>
>
> template<typename _Tp>
> struct is_standard_layout
> : public integral_constant<bool, __is_standard_layout(_Tp)>
> { };
>
>
>
> template<typename _Tp>
> struct is_pod
> : public integral_constant<bool, __is_pod(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_literal_type
> : public integral_constant<bool, __is_literal_type(_Tp)>
> { };
>
>
> 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,
> 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, static_cast<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 __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>::type
> { };
>
>
>
>
> template<typename>
> struct add_rvalue_reference;
>
>
>
>
>
> template<typename _Tp>
> typename add_rvalue_reference<_Tp>::type declval() noexcept;
>
> template<typename, unsigned = 0>
> struct extent;
>
> template<typename>
> struct remove_all_extents;
>
> template<typename _Tp>
> struct __is_array_known_bounds
> : public integral_constant<bool, (extent<_Tp>::value > 0)>
> { };
>
> template<typename _Tp>
> struct __is_array_unknown_bounds
> : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>::type
> { };
>
>
>
>
>
>
> struct __do_is_destructible_impl
> {
> template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
> };
>
> template<typename _Tp>
> struct __is_destructible_impl
> : public __do_is_destructible_impl
> {
> typedef decltype(__test<_Tp>(0)) type;
> };
>
> template<typename _Tp,
> bool = __or_<is_void<_Tp>,
> __is_array_unknown_bounds<_Tp>,
> is_function<_Tp>>::value,
> bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
> struct __is_destructible_safe;
>
> template<typename _Tp>
> struct __is_destructible_safe<_Tp, false, false>
> : public __is_destructible_impl<typename
> remove_all_extents<_Tp>::type>::type
> { };
>
> template<typename _Tp>
> struct __is_destructible_safe<_Tp, true, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_destructible_safe<_Tp, false, true>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_destructible
> : public integral_constant<bool, (__is_destructible_safe<_Tp>::value)>
> { };
>
>
>
>
>
> struct __do_is_nt_destructible_impl
> {
> template<typename _Tp>
> static integral_constant<bool, noexcept(declval<_Tp&>().~_Tp())>
> __test(int);
>
> template<typename>
> static false_type __test(...);
> };
>
> template<typename _Tp>
> struct __is_nt_destructible_impl
> : public __do_is_nt_destructible_impl
> {
> typedef decltype(__test<_Tp>(0)) type;
> };
>
> template<typename _Tp,
> bool = __or_<is_void<_Tp>,
> __is_array_unknown_bounds<_Tp>,
> is_function<_Tp>>::value,
> bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
> struct __is_nt_destructible_safe;
>
> template<typename _Tp>
> struct __is_nt_destructible_safe<_Tp, false, false>
> : public __is_nt_destructible_impl<typename
> remove_all_extents<_Tp>::type>::type
> { };
>
> template<typename _Tp>
> struct __is_nt_destructible_safe<_Tp, true, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nt_destructible_safe<_Tp, false, true>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_nothrow_destructible
> : public integral_constant<bool, (__is_nt_destructible_safe<_Tp>::value)>
> { };
>
> struct __do_is_default_constructible_impl
> {
> template<typename _Tp, typename = decltype(_Tp())>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
> };
>
> template<typename _Tp>
> struct __is_default_constructible_impl
> : public __do_is_default_constructible_impl
> {
> typedef decltype(__test<_Tp>(0)) type;
> };
>
> template<typename _Tp>
> struct __is_default_constructible_atom
> : public __and_<__not_<is_void<_Tp>>,
> __is_default_constructible_impl<_Tp>>::type
> { };
>
> template<typename _Tp, bool = is_array<_Tp>::value>
> struct __is_default_constructible_safe;
>
>
>
>
>
>
> template<typename _Tp>
> struct __is_default_constructible_safe<_Tp, true>
> : public __and_<__is_array_known_bounds<_Tp>,
> __is_default_constructible_atom<typename
> remove_all_extents<_Tp>::type>>::type
> { };
>
> template<typename _Tp>
> struct __is_default_constructible_safe<_Tp, false>
> : public __is_default_constructible_atom<_Tp>::type
> { };
>
>
> template<typename _Tp>
> struct is_default_constructible
> : public integral_constant<bool, (__is_default_constructible_safe<
> _Tp>::value)>
> { };
># 765 "/usr/include/c++/4.8.2/type_traits" 3
> struct __do_is_static_castable_impl
> {
> template<typename _From, typename _To, typename
> = decltype(static_cast<_To>(declval<_From>()))>
> static true_type __test(int);
>
> template<typename, typename>
> static false_type __test(...);
> };
>
> template<typename _From, typename _To>
> struct __is_static_castable_impl
> : public __do_is_static_castable_impl
> {
> typedef decltype(__test<_From, _To>(0)) type;
> };
>
> template<typename _From, typename _To>
> struct __is_static_castable_safe
> : public __is_static_castable_impl<_From, _To>::type
> { };
>
>
> template<typename _From, typename _To>
> struct __is_static_castable
> : public integral_constant<bool, (__is_static_castable_safe<
> _From, _To>::value)>
> { };
>
>
>
>
>
>
> struct __do_is_direct_constructible_impl
> {
> template<typename _Tp, typename _Arg, typename
> = decltype(::new _Tp(declval<_Arg>()))>
> static true_type __test(int);
>
> template<typename, typename>
> static false_type __test(...);
> };
>
> template<typename _Tp, typename _Arg>
> struct __is_direct_constructible_impl
> : public __do_is_direct_constructible_impl
> {
> typedef decltype(__test<_Tp, _Arg>(0)) type;
> };
>
> template<typename _Tp, typename _Arg>
> struct __is_direct_constructible_new_safe
> : public __and_<is_destructible<_Tp>,
> __is_direct_constructible_impl<_Tp, _Arg>>::type
> { };
>
> template<typename, typename>
> struct is_same;
>
> template<typename, typename>
> struct is_base_of;
>
> template<typename>
> struct remove_reference;
>
> template<typename _From, typename _To, bool
> = __not_<__or_<is_void<_From>,
> is_function<_From>>>::value>
> struct __is_base_to_derived_ref;
>
>
>
> template<typename _From, typename _To>
> struct __is_base_to_derived_ref<_From, _To, true>
> {
> typedef typename remove_cv<typename remove_reference<_From
> >::type>::type __src_t;
> typedef typename remove_cv<typename remove_reference<_To
> >::type>::type __dst_t;
> typedef __and_<__not_<is_same<__src_t, __dst_t>>,
> is_base_of<__src_t, __dst_t>> type;
> static constexpr bool value = type::value;
> };
>
> template<typename _From, typename _To>
> struct __is_base_to_derived_ref<_From, _To, false>
> : public false_type
> { };
>
> template<typename _From, typename _To, bool
> = __and_<is_lvalue_reference<_From>,
> is_rvalue_reference<_To>>::value>
> struct __is_lvalue_to_rvalue_ref;
>
>
>
> template<typename _From, typename _To>
> struct __is_lvalue_to_rvalue_ref<_From, _To, true>
> {
> typedef typename remove_cv<typename remove_reference<
> _From>::type>::type __src_t;
> typedef typename remove_cv<typename remove_reference<
> _To>::type>::type __dst_t;
> typedef __and_<__not_<is_function<__src_t>>,
> __or_<is_same<__src_t, __dst_t>,
> is_base_of<__dst_t, __src_t>>> type;
> static constexpr bool value = type::value;
> };
>
> template<typename _From, typename _To>
> struct __is_lvalue_to_rvalue_ref<_From, _To, false>
> : public false_type
> { };
>
>
>
>
>
>
>
> template<typename _Tp, typename _Arg>
> struct __is_direct_constructible_ref_cast
> : public __and_<__is_static_castable<_Arg, _Tp>,
> __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>,
> __is_lvalue_to_rvalue_ref<_Arg, _Tp>
> >>>::type
> { };
>
> template<typename _Tp, typename _Arg>
> struct __is_direct_constructible_new
> : public conditional<is_reference<_Tp>::value,
> __is_direct_constructible_ref_cast<_Tp, _Arg>,
> __is_direct_constructible_new_safe<_Tp, _Arg>
> >::type
> { };
>
> template<typename _Tp, typename _Arg>
> struct __is_direct_constructible
> : public integral_constant<bool, (__is_direct_constructible_new<
> _Tp, _Arg>::value)>
> { };
>
>
>
>
>
>
> struct __do_is_nary_constructible_impl
> {
> template<typename _Tp, typename... _Args, typename
> = decltype(_Tp(declval<_Args>()...))>
> static true_type __test(int);
>
> template<typename, typename...>
> static false_type __test(...);
> };
>
> template<typename _Tp, typename... _Args>
> struct __is_nary_constructible_impl
> : public __do_is_nary_constructible_impl
> {
> typedef decltype(__test<_Tp, _Args...>(0)) type;
> };
>
> template<typename _Tp, typename... _Args>
> struct __is_nary_constructible
> : public __is_nary_constructible_impl<_Tp, _Args...>::type
> {
> static_assert(sizeof...(_Args) > 1,
> "Only useful for > 1 arguments");
> };
>
> template<typename _Tp, typename... _Args>
> struct __is_constructible_impl
> : public __is_nary_constructible<_Tp, _Args...>
> { };
>
> template<typename _Tp, typename _Arg>
> struct __is_constructible_impl<_Tp, _Arg>
> : public __is_direct_constructible<_Tp, _Arg>
> { };
>
> template<typename _Tp>
> struct __is_constructible_impl<_Tp>
> : public is_default_constructible<_Tp>
> { };
>
>
> template<typename _Tp, typename... _Args>
> struct is_constructible
> : public integral_constant<bool, (__is_constructible_impl<_Tp,
> _Args...>::value)>
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_copy_constructible_impl;
>
> template<typename _Tp>
> struct __is_copy_constructible_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_copy_constructible_impl<_Tp, false>
> : public is_constructible<_Tp, const _Tp&>
> { };
>
>
> template<typename _Tp>
> struct is_copy_constructible
> : public __is_copy_constructible_impl<_Tp>
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_move_constructible_impl;
>
> template<typename _Tp>
> struct __is_move_constructible_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_move_constructible_impl<_Tp, false>
> : public is_constructible<_Tp, _Tp&&>
> { };
>
>
> template<typename _Tp>
> struct is_move_constructible
> : public __is_move_constructible_impl<_Tp>
> { };
>
> template<typename _Tp>
> struct __is_nt_default_constructible_atom
> : public integral_constant<bool, noexcept(_Tp())>
> { };
>
> template<typename _Tp, bool = is_array<_Tp>::value>
> struct __is_nt_default_constructible_impl;
>
> template<typename _Tp>
> struct __is_nt_default_constructible_impl<_Tp, true>
> : public __and_<__is_array_known_bounds<_Tp>,
> __is_nt_default_constructible_atom<typename
> remove_all_extents<_Tp>::type>>::type
> { };
>
> template<typename _Tp>
> struct __is_nt_default_constructible_impl<_Tp, false>
> : public __is_nt_default_constructible_atom<_Tp>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_default_constructible
> : public __and_<is_default_constructible<_Tp>,
> __is_nt_default_constructible_impl<_Tp>>::type
> { };
>
> template<typename _Tp, typename... _Args>
> struct __is_nt_constructible_impl
> : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
> { };
>
> template<typename _Tp, typename _Arg>
> struct __is_nt_constructible_impl<_Tp, _Arg>
> : public integral_constant<bool,
> noexcept(static_cast<_Tp>(declval<_Arg>()))>
> { };
>
> template<typename _Tp>
> struct __is_nt_constructible_impl<_Tp>
> : public is_nothrow_default_constructible<_Tp>
> { };
>
>
> template<typename _Tp, typename... _Args>
> struct is_nothrow_constructible
> : public __and_<is_constructible<_Tp, _Args...>,
> __is_nt_constructible_impl<_Tp, _Args...>>::type
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_nothrow_copy_constructible_impl;
>
> template<typename _Tp>
> struct __is_nothrow_copy_constructible_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nothrow_copy_constructible_impl<_Tp, false>
> : public is_nothrow_constructible<_Tp, const _Tp&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_copy_constructible
> : public __is_nothrow_copy_constructible_impl<_Tp>
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_nothrow_move_constructible_impl;
>
> template<typename _Tp>
> struct __is_nothrow_move_constructible_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nothrow_move_constructible_impl<_Tp, false>
> : public is_nothrow_constructible<_Tp, _Tp&&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_move_constructible
> : public __is_nothrow_move_constructible_impl<_Tp>
> { };
>
> template<typename _Tp, typename _Up>
> class __is_assignable_helper
> : public __sfinae_types
> {
> template<typename _Tp1, typename _Up1>
> static decltype(declval<_Tp1>() = declval<_Up1>(), __one())
> __test(int);
>
> template<typename, typename>
> static __two __test(...);
>
> public:
> static constexpr bool value = sizeof(__test<_Tp, _Up>(0)) == 1;
> };
>
>
> template<typename _Tp, typename _Up>
> struct is_assignable
> : public integral_constant<bool,
> __is_assignable_helper<_Tp, _Up>::value>
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_copy_assignable_impl;
>
> template<typename _Tp>
> struct __is_copy_assignable_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_copy_assignable_impl<_Tp, false>
> : public is_assignable<_Tp&, const _Tp&>
> { };
>
>
> template<typename _Tp>
> struct is_copy_assignable
> : public __is_copy_assignable_impl<_Tp>
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_move_assignable_impl;
>
> template<typename _Tp>
> struct __is_move_assignable_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_move_assignable_impl<_Tp, false>
> : public is_assignable<_Tp&, _Tp&&>
> { };
>
>
> template<typename _Tp>
> struct is_move_assignable
> : public __is_move_assignable_impl<_Tp>
> { };
>
> template<typename _Tp, typename _Up>
> struct __is_nt_assignable_impl
> : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
> { };
>
>
> template<typename _Tp, typename _Up>
> struct is_nothrow_assignable
> : public __and_<is_assignable<_Tp, _Up>,
> __is_nt_assignable_impl<_Tp, _Up>>::type
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_nt_copy_assignable_impl;
>
> template<typename _Tp>
> struct __is_nt_copy_assignable_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nt_copy_assignable_impl<_Tp, false>
> : public is_nothrow_assignable<_Tp&, const _Tp&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_copy_assignable
> : public __is_nt_copy_assignable_impl<_Tp>
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_nt_move_assignable_impl;
>
> template<typename _Tp>
> struct __is_nt_move_assignable_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nt_move_assignable_impl<_Tp, false>
> : public is_nothrow_assignable<_Tp&, _Tp&&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_move_assignable
> : public __is_nt_move_assignable_impl<_Tp>
> { };
># 1203 "/usr/include/c++/4.8.2/type_traits" 3
> template<typename _Tp>
> struct is_trivially_destructible
> : public __and_<is_destructible<_Tp>, integral_constant<bool,
> __has_trivial_destructor(_Tp)>>::type
> { };
>
>
> 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_copy_assign
> : public integral_constant<bool, __has_trivial_assign(_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 _Uint>
> 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>
> { };
>
>
>
>
>
> 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
> : public integral_constant<bool, __is_base_of(_Base, _Derived)>
> { };
>
> template<typename _From, typename _To,
> bool = __or_<is_void<_From>, is_function<_To>,
> is_array<_To>>::value>
> struct __is_convertible_helper
> { static constexpr bool value = is_void<_To>::value; };
>
> template<typename _From, typename _To>
> class __is_convertible_helper<_From, _To, false>
> : public __sfinae_types
> {
> template<typename _To1>
> static void __test_aux(_To1);
>
> template<typename _From1, typename _To1>
> static decltype(__test_aux<_To1>(std::declval<_From1>()), __one())
> __test(int);
>
> template<typename, typename>
> static __two __test(...);
>
> public:
> static constexpr bool value = sizeof(__test<_From, _To>(0)) == 1;
> };
>
>
> template<typename _From, typename _To>
> struct is_convertible
> : public integral_constant<bool,
> __is_convertible_helper<_From, _To>::value>
> { };
>
>
>
>
>
> 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;
> };
>
>
>
>
>
> template<typename _Tp>
> struct remove_reference
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_reference<_Tp&>
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_reference<_Tp&&>
> { typedef _Tp type; };
>
> template<typename _Tp,
> bool = __and_<__not_<is_reference<_Tp>>,
> __not_<is_void<_Tp>>>::value,
> bool = is_rvalue_reference<_Tp>::value>
> struct __add_lvalue_reference_helper
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct __add_lvalue_reference_helper<_Tp, true, false>
> { typedef _Tp& type; };
>
> template<typename _Tp>
> struct __add_lvalue_reference_helper<_Tp, false, true>
> { typedef typename remove_reference<_Tp>::type& type; };
>
>
> template<typename _Tp>
> struct add_lvalue_reference
> : public __add_lvalue_reference_helper<_Tp>
> { };
>
> template<typename _Tp,
> bool = __and_<__not_<is_reference<_Tp>>,
> __not_<is_void<_Tp>>>::value>
> struct __add_rvalue_reference_helper
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct __add_rvalue_reference_helper<_Tp, true>
> { typedef _Tp&& type; };
>
>
> template<typename _Tp>
> struct add_rvalue_reference
> : public __add_rvalue_reference_helper<_Tp>
> { };
>
>
>
>
>
> template<typename _Unqualified, bool _IsConst, bool _IsVol>
> struct __cv_selector;
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, false, false>
> { typedef _Unqualified __type; };
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, false, true>
> { typedef volatile _Unqualified __type; };
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, true, false>
> { typedef const _Unqualified __type; };
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, true, true>
> { typedef const volatile _Unqualified __type; };
>
> template<typename _Qualified, typename _Unqualified,
> bool _IsConst = is_const<_Qualified>::value,
> bool _IsVol = is_volatile<_Qualified>::value>
> class __match_cv_qualifiers
> {
> typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
>
> public:
> typedef typename __match::__type __type;
> };
>
>
> template<typename _Tp>
> struct __make_unsigned
> { typedef _Tp __type; };
>
> template<>
> struct __make_unsigned<char>
> { typedef unsigned char __type; };
>
> template<>
> struct __make_unsigned<signed char>
> { typedef unsigned char __type; };
>
> template<>
> struct __make_unsigned<short>
> { typedef unsigned short __type; };
>
> template<>
> struct __make_unsigned<int>
> { typedef unsigned int __type; };
>
> template<>
> struct __make_unsigned<long>
> { typedef unsigned long __type; };
>
> template<>
> struct __make_unsigned<long long>
> { typedef unsigned long long __type; };
># 1492 "/usr/include/c++/4.8.2/type_traits" 3
> template<typename _Tp,
> bool _IsInt = is_integral<_Tp>::value,
> bool _IsEnum = is_enum<_Tp>::value>
> class __make_unsigned_selector;
>
> template<typename _Tp>
> class __make_unsigned_selector<_Tp, true, false>
> {
> typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
> typedef typename __unsignedt::__type __unsigned_type;
> typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
>
> public:
> typedef typename __cv_unsigned::__type __type;
> };
>
> template<typename _Tp>
> class __make_unsigned_selector<_Tp, false, true>
> {
>
> typedef unsigned char __smallest;
> static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
> static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short);
> static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int);
> typedef conditional<__b2, unsigned int, unsigned long> __cond2;
> typedef typename __cond2::type __cond2_type;
> typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
> typedef typename __cond1::type __cond1_type;
>
> public:
> typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
> };
>
>
>
>
>
> template<typename _Tp>
> struct make_unsigned
> { typedef typename __make_unsigned_selector<_Tp>::__type type; };
>
>
> template<>
> struct make_unsigned<bool>;
>
>
>
> template<typename _Tp>
> struct __make_signed
> { typedef _Tp __type; };
>
> template<>
> struct __make_signed<char>
> { typedef signed char __type; };
>
> template<>
> struct __make_signed<unsigned char>
> { typedef signed char __type; };
>
> template<>
> struct __make_signed<unsigned short>
> { typedef signed short __type; };
>
> template<>
> struct __make_signed<unsigned int>
> { typedef signed int __type; };
>
> template<>
> struct __make_signed<unsigned long>
> { typedef signed long __type; };
>
> template<>
> struct __make_signed<unsigned long long>
> { typedef signed long long __type; };
># 1574 "/usr/include/c++/4.8.2/type_traits" 3
> template<typename _Tp,
> bool _IsInt = is_integral<_Tp>::value,
> bool _IsEnum = is_enum<_Tp>::value>
> class __make_signed_selector;
>
> template<typename _Tp>
> class __make_signed_selector<_Tp, true, false>
> {
> typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
> typedef typename __signedt::__type __signed_type;
> typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed;
>
> public:
> typedef typename __cv_signed::__type __type;
> };
>
> template<typename _Tp>
> class __make_signed_selector<_Tp, false, true>
> {
>
> typedef signed char __smallest;
> static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
> static const bool __b1 = sizeof(_Tp) <= sizeof(signed short);
> static const bool __b2 = sizeof(_Tp) <= sizeof(signed int);
> typedef conditional<__b2, signed int, signed long> __cond2;
> typedef typename __cond2::type __cond2_type;
> typedef conditional<__b1, signed short, __cond2_type> __cond1;
> typedef typename __cond1::type __cond1_type;
>
> public:
> typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
> };
>
>
>
>
>
> template<typename _Tp>
> struct make_signed
> { typedef typename __make_signed_selector<_Tp>::__type type; };
>
>
> template<>
> struct make_signed<bool>;
>
>
>
>
>
> 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; };
>
>
>
>
> template<typename _Tp, typename>
> struct __remove_pointer_helper
> { typedef _Tp type; };
>
> template<typename _Tp, typename _Up>
> struct __remove_pointer_helper<_Tp, _Up*>
> { typedef _Up type; };
>
>
> template<typename _Tp>
> struct remove_pointer
> : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
> { };
>
>
> template<typename _Tp>
> struct add_pointer
> { typedef typename remove_reference<_Tp>::type* type; };
>
>
> template<std::size_t _Len>
> struct __aligned_storage_msa
> {
> union __type
> {
> unsigned char __data[_Len];
> struct __attribute__((__aligned__)) { } __align;
> };
> };
># 1691 "/usr/include/c++/4.8.2/type_traits" 3
> template<std::size_t _Len, std::size_t _Align =
> __alignof__(typename __aligned_storage_msa<_Len>::__type)>
> struct aligned_storage
> {
> union type
> {
> unsigned char __data[_Len];
> struct __attribute__((__aligned__((_Align)))) { } __align;
> };
> };
>
>
>
>
> template<typename _Up,
> bool _IsArray = is_array<_Up>::value,
> bool _IsFunction = is_function<_Up>::value>
> struct __decay_selector;
>
>
> template<typename _Up>
> struct __decay_selector<_Up, false, false>
> { typedef typename remove_cv<_Up>::type __type; };
>
> template<typename _Up>
> struct __decay_selector<_Up, true, false>
> { typedef typename remove_extent<_Up>::type* __type; };
>
> template<typename _Up>
> struct __decay_selector<_Up, false, true>
> { typedef typename add_pointer<_Up>::type __type; };
>
>
> template<typename _Tp>
> class decay
> {
> typedef typename remove_reference<_Tp>::type __remove_type;
>
> public:
> typedef typename __decay_selector<__remove_type>::__type type;
> };
>
> template<typename _Tp>
> class 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 _Tp>
> struct __decay_and_strip
> {
> typedef typename __strip_reference_wrapper<
> typename decay<_Tp>::type>::__type __type;
> };
>
>
>
>
> template<bool, typename _Tp = void>
> struct enable_if
> { };
>
>
> template<typename _Tp>
> struct enable_if<true, _Tp>
> { typedef _Tp type; };
>
> template<typename... _Cond>
> using _Require = typename enable_if<__and_<_Cond...>::value>::type;
>
>
>
> template<bool _Cond, typename _Iftrue, typename _Iffalse>
> struct conditional
> { typedef _Iftrue type; };
>
>
> template<typename _Iftrue, typename _Iffalse>
> struct conditional<false, _Iftrue, _Iffalse>
> { typedef _Iffalse type; };
>
>
> template<typename... _Tp>
> struct common_type;
>
>
>
> struct __do_common_type_impl
> {
> template<typename _Tp, typename _Up>
> static __success_type<typename decay<decltype
> (true ? std::declval<_Tp>()
> : std::declval<_Up>())>::type> _S_test(int);
>
> template<typename, typename>
> static __failure_type _S_test(...);
> };
>
> template<typename _Tp, typename _Up>
> struct __common_type_impl
> : private __do_common_type_impl
> {
> typedef decltype(_S_test<_Tp, _Up>(0)) type;
> };
>
> struct __do_member_type_wrapper
> {
> template<typename _Tp>
> static __success_type<typename _Tp::type> _S_test(int);
>
> template<typename>
> static __failure_type _S_test(...);
> };
>
> template<typename _Tp>
> struct __member_type_wrapper
> : private __do_member_type_wrapper
> {
> typedef decltype(_S_test<_Tp>(0)) type;
> };
>
> template<typename _CTp, typename... _Args>
> struct __expanded_common_type_wrapper
> {
> typedef common_type<typename _CTp::type, _Args...> type;
> };
>
> template<typename... _Args>
> struct __expanded_common_type_wrapper<__failure_type, _Args...>
> { typedef __failure_type type; };
>
> template<typename _Tp>
> struct common_type<_Tp>
> { typedef typename decay<_Tp>::type type; };
>
> template<typename _Tp, typename _Up>
> struct common_type<_Tp, _Up>
> : public __common_type_impl<_Tp, _Up>::type
> { };
>
> template<typename _Tp, typename _Up, typename... _Vp>
> struct common_type<_Tp, _Up, _Vp...>
> : public __expanded_common_type_wrapper<typename __member_type_wrapper<
> common_type<_Tp, _Up>>::type, _Vp...>::type
> { };
>
>
> template<typename _Tp>
> struct underlying_type
> {
> typedef __underlying_type(_Tp) type;
> };
>
> template<typename _Tp>
> struct __declval_protector
> {
> static const bool __stop = false;
> static typename add_rvalue_reference<_Tp>::type __delegate();
> };
>
> template<typename _Tp>
> inline typename add_rvalue_reference<_Tp>::type
> declval() noexcept
> {
> static_assert(__declval_protector<_Tp>::__stop,
> "declval() must not be used!");
> return __declval_protector<_Tp>::__delegate();
> }
>
>
> template<typename _Signature>
> class result_of;
>
>
>
>
> struct __result_of_memfun_ref_impl
> {
> template<typename _Fp, typename _Tp1, typename... _Args>
> static __success_type<decltype(
> (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
> )> _S_test(int);
>
> template<typename...>
> static __failure_type _S_test(...);
> };
>
> template<typename _MemPtr, typename _Arg, typename... _Args>
> struct __result_of_memfun_ref
> : private __result_of_memfun_ref_impl
> {
> typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
> };
>
>
> struct __result_of_memfun_deref_impl
> {
> template<typename _Fp, typename _Tp1, typename... _Args>
> static __success_type<decltype(
> ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
> )> _S_test(int);
>
> template<typename...>
> static __failure_type _S_test(...);
> };
>
> template<typename _MemPtr, typename _Arg, typename... _Args>
> struct __result_of_memfun_deref
> : private __result_of_memfun_deref_impl
> {
> typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
> };
>
>
> struct __result_of_memobj_ref_impl
> {
> template<typename _Fp, typename _Tp1>
> static __success_type<decltype(
> std::declval<_Tp1>().*std::declval<_Fp>()
> )> _S_test(int);
>
> template<typename, typename>
> static __failure_type _S_test(...);
> };
>
> template<typename _MemPtr, typename _Arg>
> struct __result_of_memobj_ref
> : private __result_of_memobj_ref_impl
> {
> typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
> };
>
>
> struct __result_of_memobj_deref_impl
> {
> template<typename _Fp, typename _Tp1>
> static __success_type<decltype(
> (*std::declval<_Tp1>()).*std::declval<_Fp>()
> )> _S_test(int);
>
> template<typename, typename>
> static __failure_type _S_test(...);
> };
>
> template<typename _MemPtr, typename _Arg>
> struct __result_of_memobj_deref
> : private __result_of_memobj_deref_impl
> {
> typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
> };
>
> template<typename _MemPtr, typename _Arg>
> struct __result_of_memobj;
>
> template<typename _Res, typename _Class, typename _Arg>
> struct __result_of_memobj<_Res _Class::*, _Arg>
> {
> typedef typename remove_cv<typename remove_reference<
> _Arg>::type>::type _Argval;
> typedef _Res _Class::* _MemPtr;
> typedef typename conditional<__or_<is_same<_Argval, _Class>,
> is_base_of<_Class, _Argval>>::value,
> __result_of_memobj_ref<_MemPtr, _Arg>,
> __result_of_memobj_deref<_MemPtr, _Arg>
> >::type::type type;
> };
>
> template<typename _MemPtr, typename _Arg, typename... _Args>
> struct __result_of_memfun;
>
> template<typename _Res, typename _Class, typename _Arg, typename... _Args>
> struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
> {
> typedef typename remove_cv<typename remove_reference<
> _Arg>::type>::type _Argval;
> typedef _Res _Class::* _MemPtr;
> typedef typename conditional<__or_<is_same<_Argval, _Class>,
> is_base_of<_Class, _Argval>>::value,
> __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
> __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
> >::type::type type;
> };
>
> template<bool, bool, typename _Functor, typename... _ArgTypes>
> struct __result_of_impl
> {
> typedef __failure_type type;
> };
>
> template<typename _MemPtr, typename _Arg>
> struct __result_of_impl<true, false, _MemPtr, _Arg>
> : public __result_of_memobj<typename decay<_MemPtr>::type, _Arg>
> { };
>
> template<typename _MemPtr, typename _Arg, typename... _Args>
> struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
> : public __result_of_memfun<typename decay<_MemPtr>::type, _Arg, _Args...>
> { };
>
>
> struct __result_of_other_impl
> {
> template<typename _Fn, typename... _Args>
> static __success_type<decltype(
> std::declval<_Fn>()(std::declval<_Args>()...)
> )> _S_test(int);
>
> template<typename...>
> static __failure_type _S_test(...);
> };
>
> template<typename _Functor, typename... _ArgTypes>
> struct __result_of_impl<false, false, _Functor, _ArgTypes...>
> : private __result_of_other_impl
> {
> typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
> };
>
> template<typename _Functor, typename... _ArgTypes>
> struct result_of<_Functor(_ArgTypes...)>
> : public __result_of_impl<
> is_member_object_pointer<
> typename remove_reference<_Functor>::type
> >::value,
> is_member_function_pointer<
> typename remove_reference<_Functor>::type
> >::value,
> _Functor, _ArgTypes...
> >::type
> { };
># 2069 "/usr/include/c++/4.8.2/type_traits" 3
>
>}
># 58 "/usr/include/c++/4.8.2/bits/move.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 74 "/usr/include/c++/4.8.2/bits/move.h" 3
> template<typename _Tp>
> constexpr _Tp&&
> forward(typename std::remove_reference<_Tp>::type& __t) noexcept
> { return static_cast<_Tp&&>(__t); }
>
>
>
>
>
>
>
> template<typename _Tp>
> constexpr _Tp&&
> forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
> {
> static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
> " substituting _Tp is an lvalue reference type");
> return static_cast<_Tp&&>(__t);
> }
>
>
>
>
>
>
> template<typename _Tp>
> constexpr typename std::remove_reference<_Tp>::type&&
> move(_Tp&& __t) noexcept
> { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
>
>
> template<typename _Tp>
> struct __move_if_noexcept_cond
> : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
> is_copy_constructible<_Tp>>::type { };
># 118 "/usr/include/c++/4.8.2/bits/move.h" 3
> template<typename _Tp>
> inline constexpr typename
> conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
> move_if_noexcept(_Tp& __x) noexcept
> { return std::move(__x); }
># 133 "/usr/include/c++/4.8.2/bits/move.h" 3
> template<typename _Tp>
> inline _Tp*
> addressof(_Tp& __r) noexcept
> { return std::__addressof(__r); }
>
>
>
>}
># 149 "/usr/include/c++/4.8.2/bits/move.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 164 "/usr/include/c++/4.8.2/bits/move.h" 3
> template<typename _Tp>
> inline void
> swap(_Tp& __a, _Tp& __b)
>
> noexcept(__and_<is_nothrow_move_constructible<_Tp>,
> is_nothrow_move_assignable<_Tp>>::value)
>
> {
>
> 
>
> _Tp __tmp = std::move(__a);
> __a = std::move(__b);
> __b = std::move(__tmp);
> }
>
>
>
>
> template<typename _Tp, size_t _Nm>
> inline void
> swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
>
> noexcept(noexcept(swap(*__a, *__b)))
>
> {
> for (size_t __n = 0; __n < _Nm; ++__n)
> swap(__a[__n], __b[__n]);
> }
>
>
>
>}
># 60 "/usr/include/c++/4.8.2/bits/stl_pair.h" 2 3
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 76 "/usr/include/c++/4.8.2/bits/stl_pair.h" 3
> struct piecewise_construct_t { };
>
>
> constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
>
>
> template<typename...>
> class tuple;
>
> template<std::size_t...>
> struct _Index_tuple;
># 95 "/usr/include/c++/4.8.2/bits/stl_pair.h" 3
> template<class _T1, class _T2>
> struct pair
> {
> typedef _T1 first_type;
> typedef _T2 second_type;
>
> _T1 first;
> _T2 second;
>
>
>
>
>
> constexpr pair()
> : first(), second() { }
>
>
> constexpr pair(const _T1& __a, const _T2& __b)
> : first(__a), second(__b) { }
>
>
>
>
>
>
>
> template<class _U1, class _U2, class = typename
> enable_if<__and_<is_convertible<const _U1&, _T1>,
> is_convertible<const _U2&, _T2>>::value>::type>
> constexpr pair(const pair<_U1, _U2>& __p)
> : first(__p.first), second(__p.second) { }
>
> constexpr pair(const pair&) = default;
> constexpr pair(pair&&) = default;
>
>
> template<class _U1, class = typename
> enable_if<is_convertible<_U1, _T1>::value>::type>
> constexpr pair(_U1&& __x, const _T2& __y)
> : first(std::forward<_U1>(__x)), second(__y) { }
>
> template<class _U2, class = typename
> enable_if<is_convertible<_U2, _T2>::value>::type>
> constexpr pair(const _T1& __x, _U2&& __y)
> : first(__x), second(std::forward<_U2>(__y)) { }
>
> template<class _U1, class _U2, class = typename
> enable_if<__and_<is_convertible<_U1, _T1>,
> is_convertible<_U2, _T2>>::value>::type>
> constexpr pair(_U1&& __x, _U2&& __y)
> : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
>
> template<class _U1, class _U2, class = typename
> enable_if<__and_<is_convertible<_U1, _T1>,
> is_convertible<_U2, _T2>>::value>::type>
> constexpr pair(pair<_U1, _U2>&& __p)
> : first(std::forward<_U1>(__p.first)),
> second(std::forward<_U2>(__p.second)) { }
>
> template<typename... _Args1, typename... _Args2>
> pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
>
> pair&
> operator=(const pair& __p)
> {
> first = __p.first;
> second = __p.second;
> return *this;
> }
>
> pair&
> operator=(pair&& __p)
> noexcept(__and_<is_nothrow_move_assignable<_T1>,
> is_nothrow_move_assignable<_T2>>::value)
> {
> first = std::forward<first_type>(__p.first);
> second = std::forward<second_type>(__p.second);
> return *this;
> }
>
> template<class _U1, class _U2>
> pair&
> operator=(const pair<_U1, _U2>& __p)
> {
> first = __p.first;
> second = __p.second;
> return *this;
> }
>
> template<class _U1, class _U2>
> pair&
> operator=(pair<_U1, _U2>&& __p)
> {
> first = std::forward<_U1>(__p.first);
> second = std::forward<_U2>(__p.second);
> return *this;
> }
>
> void
> swap(pair& __p)
> noexcept(noexcept(swap(first, __p.first))
> && noexcept(swap(second, __p.second)))
> {
> using std::swap;
> swap(first, __p.first);
> swap(second, __p.second);
> }
>
> private:
> template<typename... _Args1, std::size_t... _Indexes1,
> typename... _Args2, std::size_t... _Indexes2>
> pair(tuple<_Args1...>&, tuple<_Args2...>&,
> _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
>
> };
>
>
> template<class _T1, class _T2>
> inline constexpr bool
> operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return __x.first == __y.first && __x.second == __y.second; }
>
>
> template<class _T1, class _T2>
> inline constexpr bool
> operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return __x.first < __y.first
> || (!(__y.first < __x.first) && __x.second < __y.second); }
>
>
> template<class _T1, class _T2>
> inline constexpr bool
> operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return !(__x == __y); }
>
>
> template<class _T1, class _T2>
> inline constexpr bool
> operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return __y < __x; }
>
>
> template<class _T1, class _T2>
> inline constexpr bool
> operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return !(__y < __x); }
>
>
> template<class _T1, class _T2>
> inline constexpr bool
> operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return !(__x < __y); }
>
>
>
>
>
> template<class _T1, class _T2>
> inline void
> swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
># 273 "/usr/include/c++/4.8.2/bits/stl_pair.h" 3
> template<class _T1, class _T2>
> constexpr pair<typename __decay_and_strip<_T1>::__type,
> typename __decay_and_strip<_T2>::__type>
> make_pair(_T1&& __x, _T2&& __y)
> {
> typedef typename __decay_and_strip<_T1>::__type __ds_type1;
> typedef typename __decay_and_strip<_T2>::__type __ds_type2;
> typedef pair<__ds_type1, __ds_type2> __pair_type;
> return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
> }
># 292 "/usr/include/c++/4.8.2/bits/stl_pair.h" 3
>
>}
># 65 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/4.8.2/bits/stl_iterator_base_types.h" 1 3
># 62 "/usr/include/c++/4.8.2/bits/stl_iterator_base_types.h" 3
> 
># 63 "/usr/include/c++/4.8.2/bits/stl_iterator_base_types.h" 3
>
>
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 89 "/usr/include/c++/4.8.2/bits/stl_iterator_base_types.h" 3
> struct input_iterator_tag { };
>
>
> struct output_iterator_tag { };
>
>
> struct forward_iterator_tag : public input_iterator_tag { };
>
>
>
> struct bidirectional_iterator_tag : public forward_iterator_tag { };
>
>
>
> struct random_access_iterator_tag : public bidirectional_iterator_tag { };
># 116 "/usr/include/c++/4.8.2/bits/stl_iterator_base_types.h" 3
> template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
> typename _Pointer = _Tp*, typename _Reference = _Tp&>
> struct iterator
> {
>
> typedef _Category iterator_category;
>
> typedef _Tp value_type;
>
> typedef _Distance difference_type;
>
> typedef _Pointer pointer;
>
> typedef _Reference reference;
> };
># 142 "/usr/include/c++/4.8.2/bits/stl_iterator_base_types.h" 3
>template<typename _Tp> class __has_iterator_category_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::iterator_category>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_iterator_category : integral_constant<bool, __has_iterator_category_helper <typename remove_cv<_Tp>::type>::value> { };
>
> template<typename _Iterator,
> bool = __has_iterator_category<_Iterator>::value>
> struct __iterator_traits { };
>
> template<typename _Iterator>
> struct __iterator_traits<_Iterator, true>
> {
> typedef typename _Iterator::iterator_category iterator_category;
> typedef typename _Iterator::value_type value_type;
> typedef typename _Iterator::difference_type difference_type;
> typedef typename _Iterator::pointer pointer;
> typedef typename _Iterator::reference reference;
> };
>
> template<typename _Iterator>
> struct iterator_traits
> : public __iterator_traits<_Iterator> { };
># 174 "/usr/include/c++/4.8.2/bits/stl_iterator_base_types.h" 3
> template<typename _Tp>
> struct iterator_traits<_Tp*>
> {
> typedef random_access_iterator_tag iterator_category;
> typedef _Tp value_type;
> typedef ptrdiff_t difference_type;
> typedef _Tp* pointer;
> typedef _Tp& reference;
> };
>
>
> template<typename _Tp>
> struct iterator_traits<const _Tp*>
> {
> typedef random_access_iterator_tag iterator_category;
> typedef _Tp value_type;
> typedef ptrdiff_t difference_type;
> typedef const _Tp* pointer;
> typedef const _Tp& reference;
> };
>
>
>
>
>
> template<typename _Iter>
> inline typename iterator_traits<_Iter>::iterator_category
> __iterator_category(const _Iter&)
> { return typename iterator_traits<_Iter>::iterator_category(); }
>
>
>
>
>
> template<typename _Iterator, bool _HasBase>
> struct _Iter_base
> {
> typedef _Iterator iterator_type;
> static iterator_type _S_base(_Iterator __it)
> { return __it; }
> };
>
> template<typename _Iterator>
> struct _Iter_base<_Iterator, true>
> {
> typedef typename _Iterator::iterator_type iterator_type;
> static iterator_type _S_base(_Iterator __it)
> { return __it.base(); }
> };
>
>
> template<typename _InIter>
> using _RequireInputIter = typename
> enable_if<is_convertible<typename
> iterator_traits<_InIter>::iterator_category,
> input_iterator_tag>::value>::type;
>
>
>
>}
># 66 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/4.8.2/bits/stl_iterator_base_funcs.h" 1 3
># 62 "/usr/include/c++/4.8.2/bits/stl_iterator_base_funcs.h" 3
> 
># 63 "/usr/include/c++/4.8.2/bits/stl_iterator_base_funcs.h" 3
>
>
># 1 "/usr/include/c++/4.8.2/debug/debug.h" 1 3
># 46 "/usr/include/c++/4.8.2/debug/debug.h" 3
>namespace std
>{
> namespace __debug { }
>}
>
>
>
>
>namespace __gnu_debug
>{
> using namespace std::__debug;
>}
># 66 "/usr/include/c++/4.8.2/bits/stl_iterator_base_funcs.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _InputIterator>
> inline typename iterator_traits<_InputIterator>::difference_type
> __distance(_InputIterator __first, _InputIterator __last,
> input_iterator_tag)
> {
>
> 
>
> typename iterator_traits<_InputIterator>::difference_type __n = 0;
> while (__first != __last)
> {
> ++__first;
> ++__n;
> }
> return __n;
> }
>
> template<typename _RandomAccessIterator>
> inline typename iterator_traits<_RandomAccessIterator>::difference_type
> __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
> random_access_iterator_tag)
> {
>
> 
>
> return __last - __first;
> }
># 112 "/usr/include/c++/4.8.2/bits/stl_iterator_base_funcs.h" 3
> template<typename _InputIterator>
> inline typename iterator_traits<_InputIterator>::difference_type
> distance(_InputIterator __first, _InputIterator __last)
> {
>
> return std::__distance(__first, __last,
> std::__iterator_category(__first));
> }
>
> template<typename _InputIterator, typename _Distance>
> inline void
> __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
> {
>
> 
> ;
> while (__n--)
> ++__i;
> }
>
> template<typename _BidirectionalIterator, typename _Distance>
> inline void
> __advance(_BidirectionalIterator& __i, _Distance __n,
> bidirectional_iterator_tag)
> {
>
> 
>
> if (__n > 0)
> while (__n--)
> ++__i;
> else
> while (__n++)
> --__i;
> }
>
> template<typename _RandomAccessIterator, typename _Distance>
> inline void
> __advance(_RandomAccessIterator& __i, _Distance __n,
> random_access_iterator_tag)
> {
>
> 
>
> __i += __n;
> }
># 171 "/usr/include/c++/4.8.2/bits/stl_iterator_base_funcs.h" 3
> template<typename _InputIterator, typename _Distance>
> inline void
> advance(_InputIterator& __i, _Distance __n)
> {
>
> typename iterator_traits<_InputIterator>::difference_type __d = __n;
> std::__advance(__i, __d, std::__iterator_category(__i));
> }
>
>
>
> template<typename _ForwardIterator>
> inline _ForwardIterator
> next(_ForwardIterator __x, typename
> iterator_traits<_ForwardIterator>::difference_type __n = 1)
> {
> std::advance(__x, __n);
> return __x;
> }
>
> template<typename _BidirectionalIterator>
> inline _BidirectionalIterator
> prev(_BidirectionalIterator __x, typename
> iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
> {
> std::advance(__x, -__n);
> return __x;
> }
>
>
>
>
>}
># 67 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 1 3
># 67 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 95 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
> template<typename _Iterator>
> class reverse_iterator
> : public iterator<typename iterator_traits<_Iterator>::iterator_category,
> typename iterator_traits<_Iterator>::value_type,
> typename iterator_traits<_Iterator>::difference_type,
> typename iterator_traits<_Iterator>::pointer,
> typename iterator_traits<_Iterator>::reference>
> {
> protected:
> _Iterator current;
>
> typedef iterator_traits<_Iterator> __traits_type;
>
> public:
> typedef _Iterator iterator_type;
> typedef typename __traits_type::difference_type difference_type;
> typedef typename __traits_type::pointer pointer;
> typedef typename __traits_type::reference reference;
>
>
>
>
>
>
>
> reverse_iterator() : current() { }
>
>
>
>
> explicit
> reverse_iterator(iterator_type __x) : current(__x) { }
>
>
>
>
> reverse_iterator(const reverse_iterator& __x)
> : current(__x.current) { }
>
>
>
>
>
> template<typename _Iter>
> reverse_iterator(const reverse_iterator<_Iter>& __x)
> : current(__x.base()) { }
>
>
>
>
> iterator_type
> base() const
> { return current; }
># 159 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
> reference
> operator*() const
> {
> _Iterator __tmp = current;
> return *--__tmp;
> }
>
>
>
>
>
>
> pointer
> operator->() const
> { return &(operator*()); }
>
>
>
>
>
>
> reverse_iterator&
> operator++()
> {
> --current;
> return *this;
> }
>
>
>
>
>
>
> reverse_iterator
> operator++(int)
> {
> reverse_iterator __tmp = *this;
> --current;
> return __tmp;
> }
>
>
>
>
>
>
> reverse_iterator&
> operator--()
> {
> ++current;
> return *this;
> }
>
>
>
>
>
>
> reverse_iterator
> operator--(int)
> {
> reverse_iterator __tmp = *this;
> ++current;
> return __tmp;
> }
>
>
>
>
>
>
> reverse_iterator
> operator+(difference_type __n) const
> { return reverse_iterator(current - __n); }
>
>
>
>
>
>
>
> reverse_iterator&
> operator+=(difference_type __n)
> {
> current -= __n;
> return *this;
> }
>
>
>
>
>
>
> reverse_iterator
> operator-(difference_type __n) const
> { return reverse_iterator(current + __n); }
>
>
>
>
>
>
>
> reverse_iterator&
> operator-=(difference_type __n)
> {
> current += __n;
> return *this;
> }
>
>
>
>
>
>
> reference
> operator[](difference_type __n) const
> { return *(*this + __n); }
> };
># 289 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
> template<typename _Iterator>
> inline bool
> operator==(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return __x.base() == __y.base(); }
>
> template<typename _Iterator>
> inline bool
> operator<(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return __y.base() < __x.base(); }
>
> template<typename _Iterator>
> inline bool
> operator!=(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return !(__x == __y); }
>
> template<typename _Iterator>
> inline bool
> operator>(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return __y < __x; }
>
> template<typename _Iterator>
> inline bool
> operator<=(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return !(__y < __x); }
>
> template<typename _Iterator>
> inline bool
> operator>=(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return !(__x < __y); }
>
> template<typename _Iterator>
> inline typename reverse_iterator<_Iterator>::difference_type
> operator-(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return __y.base() - __x.base(); }
>
> template<typename _Iterator>
> inline reverse_iterator<_Iterator>
> operator+(typename reverse_iterator<_Iterator>::difference_type __n,
> const reverse_iterator<_Iterator>& __x)
> { return reverse_iterator<_Iterator>(__x.base() - __n); }
>
>
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator==(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return __x.base() == __y.base(); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator<(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return __y.base() < __x.base(); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator!=(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return !(__x == __y); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator>(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return __y < __x; }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator<=(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return !(__y < __x); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator>=(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return !(__x < __y); }
>
> template<typename _IteratorL, typename _IteratorR>
>
>
> inline auto
> operator-(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> -> decltype(__y.base() - __x.base())
>
>
>
>
>
> { return __y.base() - __x.base(); }
># 401 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
> template<typename _Container>
> class back_insert_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _Container* container;
>
> public:
>
> typedef _Container container_type;
>
>
> explicit
> back_insert_iterator(_Container& __x) : container(&__x) { }
># 435 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
> back_insert_iterator&
> operator=(const typename _Container::value_type& __value)
> {
> container->push_back(__value);
> return *this;
> }
>
> back_insert_iterator&
> operator=(typename _Container::value_type&& __value)
> {
> container->push_back(std::move(__value));
> return *this;
> }
>
>
>
> back_insert_iterator&
> operator*()
> { return *this; }
>
>
> back_insert_iterator&
> operator++()
> { return *this; }
>
>
> back_insert_iterator
> operator++(int)
> { return *this; }
> };
># 477 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
> template<typename _Container>
> inline back_insert_iterator<_Container>
> back_inserter(_Container& __x)
> { return back_insert_iterator<_Container>(__x); }
># 492 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
> template<typename _Container>
> class front_insert_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _Container* container;
>
> public:
>
> typedef _Container container_type;
>
>
> explicit front_insert_iterator(_Container& __x) : container(&__x) { }
># 525 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
> front_insert_iterator&
> operator=(const typename _Container::value_type& __value)
> {
> container->push_front(__value);
> return *this;
> }
>
> front_insert_iterator&
> operator=(typename _Container::value_type&& __value)
> {
> container->push_front(std::move(__value));
> return *this;
> }
>
>
>
> front_insert_iterator&
> operator*()
> { return *this; }
>
>
> front_insert_iterator&
> operator++()
> { return *this; }
>
>
> front_insert_iterator
> operator++(int)
> { return *this; }
> };
># 567 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
> template<typename _Container>
> inline front_insert_iterator<_Container>
> front_inserter(_Container& __x)
> { return front_insert_iterator<_Container>(__x); }
># 586 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
> template<typename _Container>
> class insert_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _Container* container;
> typename _Container::iterator iter;
>
> public:
>
> typedef _Container container_type;
>
>
>
>
>
> insert_iterator(_Container& __x, typename _Container::iterator __i)
> : container(&__x), iter(__i) {}
># 637 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
> insert_iterator&
> operator=(const typename _Container::value_type& __value)
> {
> iter = container->insert(iter, __value);
> ++iter;
> return *this;
> }
>
> insert_iterator&
> operator=(typename _Container::value_type&& __value)
> {
> iter = container->insert(iter, std::move(__value));
> ++iter;
> return *this;
> }
>
>
>
> insert_iterator&
> operator*()
> { return *this; }
>
>
> insert_iterator&
> operator++()
> { return *this; }
>
>
> insert_iterator&
> operator++(int)
> { return *this; }
> };
># 681 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
> template<typename _Container, typename _Iterator>
> inline insert_iterator<_Container>
> inserter(_Container& __x, _Iterator __i)
> {
> return insert_iterator<_Container>(__x,
> typename _Container::iterator(__i));
> }
>
>
>
>
>}
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
># 705 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
> using std::iterator_traits;
> using std::iterator;
> template<typename _Iterator, typename _Container>
> class __normal_iterator
> {
> protected:
> _Iterator _M_current;
>
> typedef iterator_traits<_Iterator> __traits_type;
>
> public:
> typedef _Iterator iterator_type;
> typedef typename __traits_type::iterator_category iterator_category;
> typedef typename __traits_type::value_type value_type;
> typedef typename __traits_type::difference_type difference_type;
> typedef typename __traits_type::reference reference;
> typedef typename __traits_type::pointer pointer;
>
> constexpr __normal_iterator() : _M_current(_Iterator()) { }
>
> explicit
> __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
>
>
> template<typename _Iter>
> __normal_iterator(const __normal_iterator<_Iter,
> typename __enable_if<
> (std::__are_same<_Iter, typename _Container::pointer>::__value),
> _Container>::__type>& __i)
> : _M_current(__i.base()) { }
>
>
> reference
> operator*() const
> { return *_M_current; }
>
> pointer
> operator->() const
> { return _M_current; }
>
> __normal_iterator&
> operator++()
> {
> ++_M_current;
> return *this;
> }
>
> __normal_iterator
> operator++(int)
> { return __normal_iterator(_M_current++); }
>
>
> __normal_iterator&
> operator--()
> {
> --_M_current;
> return *this;
> }
>
> __normal_iterator
> operator--(int)
> { return __normal_iterator(_M_current--); }
>
>
> reference
> operator[](const difference_type& __n) const
> { return _M_current[__n]; }
>
> __normal_iterator&
> operator+=(const difference_type& __n)
> { _M_current += __n; return *this; }
>
> __normal_iterator
> operator+(const difference_type& __n) const
> { return __normal_iterator(_M_current + __n); }
>
> __normal_iterator&
> operator-=(const difference_type& __n)
> { _M_current -= __n; return *this; }
>
> __normal_iterator
> operator-(const difference_type& __n) const
> { return __normal_iterator(_M_current - __n); }
>
> const _Iterator&
> base() const
> { return _M_current; }
> };
># 803 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() == __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() == __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() != __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() != __rhs.base(); }
>
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() < __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() < __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() > __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() > __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() <= __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() <= __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() >= __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() >= __rhs.base(); }
>
>
>
>
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
>
>
> inline auto
> operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> -> decltype(__lhs.base() - __rhs.base())
>
>
>
>
>
> { return __lhs.base() - __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline typename __normal_iterator<_Iterator, _Container>::difference_type
> operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() - __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline __normal_iterator<_Iterator, _Container>
> operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
> __n, const __normal_iterator<_Iterator, _Container>& __i)
> { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
>
>
>}
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 929 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
> template<typename _Iterator>
> class move_iterator
> {
> protected:
> _Iterator _M_current;
>
> typedef iterator_traits<_Iterator> __traits_type;
>
> public:
> typedef _Iterator iterator_type;
> typedef typename __traits_type::iterator_category iterator_category;
> typedef typename __traits_type::value_type value_type;
> typedef typename __traits_type::difference_type difference_type;
>
> typedef _Iterator pointer;
> typedef value_type&& reference;
>
> move_iterator()
> : _M_current() { }
>
> explicit
> move_iterator(iterator_type __i)
> : _M_current(__i) { }
>
> template<typename _Iter>
> move_iterator(const move_iterator<_Iter>& __i)
> : _M_current(__i.base()) { }
>
> iterator_type
> base() const
> { return _M_current; }
>
> reference
> operator*() const
> { return std::move(*_M_current); }
>
> pointer
> operator->() const
> { return _M_current; }
>
> move_iterator&
> operator++()
> {
> ++_M_current;
> return *this;
> }
>
> move_iterator
> operator++(int)
> {
> move_iterator __tmp = *this;
> ++_M_current;
> return __tmp;
> }
>
> move_iterator&
> operator--()
> {
> --_M_current;
> return *this;
> }
>
> move_iterator
> operator--(int)
> {
> move_iterator __tmp = *this;
> --_M_current;
> return __tmp;
> }
>
> move_iterator
> operator+(difference_type __n) const
> { return move_iterator(_M_current + __n); }
>
> move_iterator&
> operator+=(difference_type __n)
> {
> _M_current += __n;
> return *this;
> }
>
> move_iterator
> operator-(difference_type __n) const
> { return move_iterator(_M_current - __n); }
>
> move_iterator&
> operator-=(difference_type __n)
> {
> _M_current -= __n;
> return *this;
> }
>
> reference
> operator[](difference_type __n) const
> { return std::move(_M_current[__n]); }
> };
>
>
>
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator==(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return __x.base() == __y.base(); }
>
> template<typename _Iterator>
> inline bool
> operator==(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return __x.base() == __y.base(); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator!=(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return !(__x == __y); }
>
> template<typename _Iterator>
> inline bool
> operator!=(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return !(__x == __y); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator<(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return __x.base() < __y.base(); }
>
> template<typename _Iterator>
> inline bool
> operator<(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return __x.base() < __y.base(); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator<=(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return !(__y < __x); }
>
> template<typename _Iterator>
> inline bool
> operator<=(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return !(__y < __x); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator>(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return __y < __x; }
>
> template<typename _Iterator>
> inline bool
> operator>(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return __y < __x; }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator>=(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return !(__x < __y); }
>
> template<typename _Iterator>
> inline bool
> operator>=(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return !(__x < __y); }
>
>
> template<typename _IteratorL, typename _IteratorR>
> inline auto
> operator-(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> -> decltype(__x.base() - __y.base())
> { return __x.base() - __y.base(); }
>
> template<typename _Iterator>
> inline auto
> operator-(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> -> decltype(__x.base() - __y.base())
> { return __x.base() - __y.base(); }
>
> template<typename _Iterator>
> inline move_iterator<_Iterator>
> operator+(typename move_iterator<_Iterator>::difference_type __n,
> const move_iterator<_Iterator>& __x)
> { return __x + __n; }
>
> template<typename _Iterator>
> inline move_iterator<_Iterator>
> make_move_iterator(_Iterator __i)
> { return move_iterator<_Iterator>(__i); }
>
> template<typename _Iterator, typename _ReturnType
> = typename conditional<__move_if_noexcept_cond
> <typename iterator_traits<_Iterator>::value_type>::value,
> _Iterator, move_iterator<_Iterator>>::type>
> inline _ReturnType
> __make_move_if_noexcept_iterator(_Iterator __i)
> { return _ReturnType(__i); }
>
>
>
>
>}
># 68 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 2 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 117 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> inline void
> iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
> {
>
> 
>
> 
># 147 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> swap(*__a, *__b);
>
> }
># 163 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> _ForwardIterator2
> swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2)
> {
>
> 
>
> 
>
> ;
>
> for (; __first1 != __last1; ++__first1, ++__first2)
> std::iter_swap(__first1, __first2);
> return __first2;
> }
># 191 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _Tp>
> inline const _Tp&
> min(const _Tp& __a, const _Tp& __b)
> {
>
> 
>
> if (__b < __a)
> return __b;
> return __a;
> }
># 214 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _Tp>
> inline const _Tp&
> max(const _Tp& __a, const _Tp& __b)
> {
>
> 
>
> if (__a < __b)
> return __b;
> return __a;
> }
># 237 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _Tp, typename _Compare>
> inline const _Tp&
> min(const _Tp& __a, const _Tp& __b, _Compare __comp)
> {
>
> if (__comp(__b, __a))
> return __b;
> return __a;
> }
># 258 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _Tp, typename _Compare>
> inline const _Tp&
> max(const _Tp& __a, const _Tp& __b, _Compare __comp)
> {
>
> if (__comp(__a, __b))
> return __b;
> return __a;
> }
>
>
>
> template<typename _Iterator>
> struct _Niter_base
> : _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
> { };
>
> template<typename _Iterator>
> inline typename _Niter_base<_Iterator>::iterator_type
> __niter_base(_Iterator __it)
> { return std::_Niter_base<_Iterator>::_S_base(__it); }
>
>
> template<typename _Iterator>
> struct _Miter_base
> : _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
> { };
>
> template<typename _Iterator>
> inline typename _Miter_base<_Iterator>::iterator_type
> __miter_base(_Iterator __it)
> { return std::_Miter_base<_Iterator>::_S_base(__it); }
>
>
>
>
>
>
>
> template<bool, bool, typename>
> struct __copy_move
> {
> template<typename _II, typename _OI>
> static _OI
> __copy_m(_II __first, _II __last, _OI __result)
> {
> for (; __first != __last; ++__result, ++__first)
> *__result = *__first;
> return __result;
> }
> };
>
>
> template<typename _Category>
> struct __copy_move<true, false, _Category>
> {
> template<typename _II, typename _OI>
> static _OI
> __copy_m(_II __first, _II __last, _OI __result)
> {
> for (; __first != __last; ++__result, ++__first)
> *__result = std::move(*__first);
> return __result;
> }
> };
>
>
> template<>
> struct __copy_move<false, false, random_access_iterator_tag>
> {
> template<typename _II, typename _OI>
> static _OI
> __copy_m(_II __first, _II __last, _OI __result)
> {
> typedef typename iterator_traits<_II>::difference_type _Distance;
> for(_Distance __n = __last - __first; __n > 0; --__n)
> {
> *__result = *__first;
> ++__first;
> ++__result;
> }
> return __result;
> }
> };
>
>
> template<>
> struct __copy_move<true, false, random_access_iterator_tag>
> {
> template<typename _II, typename _OI>
> static _OI
> __copy_m(_II __first, _II __last, _OI __result)
> {
> typedef typename iterator_traits<_II>::difference_type _Distance;
> for(_Distance __n = __last - __first; __n > 0; --__n)
> {
> *__result = std::move(*__first);
> ++__first;
> ++__result;
> }
> return __result;
> }
> };
>
>
> template<bool _IsMove>
> struct __copy_move<_IsMove, true, random_access_iterator_tag>
> {
> template<typename _Tp>
> static _Tp*
> __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
> {
> const ptrdiff_t _Num = __last - __first;
> if (_Num)
> __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
> return __result + _Num;
> }
> };
>
> template<bool _IsMove, typename _II, typename _OI>
> inline _OI
> __copy_move_a(_II __first, _II __last, _OI __result)
> {
> typedef typename iterator_traits<_II>::value_type _ValueTypeI;
> typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
> typedef typename iterator_traits<_II>::iterator_category _Category;
> const bool __simple = (__is_trivial(_ValueTypeI)
> && __is_pointer<_II>::__value
> && __is_pointer<_OI>::__value
> && __are_same<_ValueTypeI, _ValueTypeO>::__value);
>
> return std::__copy_move<_IsMove, __simple,
> _Category>::__copy_m(__first, __last, __result);
> }
>
>
>
> template<typename _CharT>
> struct char_traits;
>
> template<typename _CharT, typename _Traits>
> class istreambuf_iterator;
>
> template<typename _CharT, typename _Traits>
> class ostreambuf_iterator;
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
> __copy_move_a2(_CharT*, _CharT*,
> ostreambuf_iterator<_CharT, char_traits<_CharT> >);
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
> __copy_move_a2(const _CharT*, const _CharT*,
> ostreambuf_iterator<_CharT, char_traits<_CharT> >);
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> _CharT*>::__type
> __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
> istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);
>
> template<bool _IsMove, typename _II, typename _OI>
> inline _OI
> __copy_move_a2(_II __first, _II __last, _OI __result)
> {
> return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
> std::__niter_base(__last),
> std::__niter_base(__result)));
> }
># 448 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _II, typename _OI>
> inline _OI
> copy(_II __first, _II __last, _OI __result)
> {
>
> 
> 
>
> ;
>
> return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
> (std::__miter_base(__first), std::__miter_base(__last),
> __result));
> }
># 481 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _II, typename _OI>
> inline _OI
> move(_II __first, _II __last, _OI __result)
> {
>
> 
> 
>
> ;
>
> return std::__copy_move_a2<true>(std::__miter_base(__first),
> std::__miter_base(__last), __result);
> }
>
>
>
>
>
>
> template<bool, bool, typename>
> struct __copy_move_backward
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> while (__first != __last)
> *--__result = *--__last;
> return __result;
> }
> };
>
>
> template<typename _Category>
> struct __copy_move_backward<true, false, _Category>
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> while (__first != __last)
> *--__result = std::move(*--__last);
> return __result;
> }
> };
>
>
> template<>
> struct __copy_move_backward<false, false, random_access_iterator_tag>
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> typename iterator_traits<_BI1>::difference_type __n;
> for (__n = __last - __first; __n > 0; --__n)
> *--__result = *--__last;
> return __result;
> }
> };
>
>
> template<>
> struct __copy_move_backward<true, false, random_access_iterator_tag>
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> typename iterator_traits<_BI1>::difference_type __n;
> for (__n = __last - __first; __n > 0; --__n)
> *--__result = std::move(*--__last);
> return __result;
> }
> };
>
>
> template<bool _IsMove>
> struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
> {
> template<typename _Tp>
> static _Tp*
> __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
> {
> const ptrdiff_t _Num = __last - __first;
> if (_Num)
> __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
> return __result - _Num;
> }
> };
>
> template<bool _IsMove, typename _BI1, typename _BI2>
> inline _BI2
> __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> typedef typename iterator_traits<_BI1>::value_type _ValueType1;
> typedef typename iterator_traits<_BI2>::value_type _ValueType2;
> typedef typename iterator_traits<_BI1>::iterator_category _Category;
> const bool __simple = (__is_trivial(_ValueType1)
> && __is_pointer<_BI1>::__value
> && __is_pointer<_BI2>::__value
> && __are_same<_ValueType1, _ValueType2>::__value);
>
> return std::__copy_move_backward<_IsMove, __simple,
> _Category>::__copy_move_b(__first,
> __last,
> __result);
> }
>
> template<bool _IsMove, typename _BI1, typename _BI2>
> inline _BI2
> __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> return _BI2(std::__copy_move_backward_a<_IsMove>
> (std::__niter_base(__first), std::__niter_base(__last),
> std::__niter_base(__result)));
> }
># 617 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _BI1, typename _BI2>
> inline _BI2
> copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
> {
>
> 
> 
> 
>
>
> ;
>
> return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
> (std::__miter_base(__first), std::__miter_base(__last),
> __result));
> }
># 653 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _BI1, typename _BI2>
> inline _BI2
> move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
> {
>
> 
> 
> 
>
>
> ;
>
> return std::__copy_move_backward_a2<true>(std::__miter_base(__first),
> std::__miter_base(__last),
> __result);
> }
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
> __fill_a(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __value)
> {
> for (; __first != __last; ++__first)
> *__first = __value;
> }
>
> template<typename _ForwardIterator, typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
> __fill_a(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __value)
> {
> const _Tp __tmp = __value;
> for (; __first != __last; ++__first)
> *__first = __tmp;
> }
>
>
> template<typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
> __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
> {
> const _Tp __tmp = __c;
> __builtin_memset(__first, static_cast<unsigned char>(__tmp),
> __last - __first);
> }
># 719 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _ForwardIterator, typename _Tp>
> inline void
> fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
> {
>
> 
>
> ;
>
> std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
> __value);
> }
>
> template<typename _OutputIterator, typename _Size, typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
> __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
> {
> for (__decltype(__n + 0) __niter = __n;
> __niter > 0; --__niter, ++__first)
> *__first = __value;
> return __first;
> }
>
> template<typename _OutputIterator, typename _Size, typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
> __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
> {
> const _Tp __tmp = __value;
> for (__decltype(__n + 0) __niter = __n;
> __niter > 0; --__niter, ++__first)
> *__first = __tmp;
> return __first;
> }
>
> template<typename _Size, typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
> __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
> {
> std::__fill_a(__first, __first + __n, __c);
> return __first + __n;
> }
># 779 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _OI, typename _Size, typename _Tp>
> inline _OI
> fill_n(_OI __first, _Size __n, const _Tp& __value)
> {
>
> 
>
> return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
> }
>
> template<bool _BoolType>
> struct __equal
> {
> template<typename _II1, typename _II2>
> static bool
> equal(_II1 __first1, _II1 __last1, _II2 __first2)
> {
> for (; __first1 != __last1; ++__first1, ++__first2)
> if (!(*__first1 == *__first2))
> return false;
> return true;
> }
> };
>
> template<>
> struct __equal<true>
> {
> template<typename _Tp>
> static bool
> equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
> {
> return !__builtin_memcmp(__first1, __first2, sizeof(_Tp)
> * (__last1 - __first1));
> }
> };
>
> template<typename _II1, typename _II2>
> inline bool
> __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
> {
> typedef typename iterator_traits<_II1>::value_type _ValueType1;
> typedef typename iterator_traits<_II2>::value_type _ValueType2;
> const bool __simple = ((__is_integer<_ValueType1>::__value
> || __is_pointer<_ValueType1>::__value)
> && __is_pointer<_II1>::__value
> && __is_pointer<_II2>::__value
> && __are_same<_ValueType1, _ValueType2>::__value);
>
> return std::__equal<__simple>::equal(__first1, __last1, __first2);
> }
>
>
> template<typename, typename>
> struct __lc_rai
> {
> template<typename _II1, typename _II2>
> static _II1
> __newlast1(_II1, _II1 __last1, _II2, _II2)
> { return __last1; }
>
> template<typename _II>
> static bool
> __cnd2(_II __first, _II __last)
> { return __first != __last; }
> };
>
> template<>
> struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
> {
> template<typename _RAI1, typename _RAI2>
> static _RAI1
> __newlast1(_RAI1 __first1, _RAI1 __last1,
> _RAI2 __first2, _RAI2 __last2)
> {
> const typename iterator_traits<_RAI1>::difference_type
> __diff1 = __last1 - __first1;
> const typename iterator_traits<_RAI2>::difference_type
> __diff2 = __last2 - __first2;
> return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
> }
>
> template<typename _RAI>
> static bool
> __cnd2(_RAI, _RAI)
> { return true; }
> };
>
> template<bool _BoolType>
> struct __lexicographical_compare
> {
> template<typename _II1, typename _II2>
> static bool __lc(_II1, _II1, _II2, _II2);
> };
>
> template<bool _BoolType>
> template<typename _II1, typename _II2>
> bool
> __lexicographical_compare<_BoolType>::
> __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
> {
> typedef typename iterator_traits<_II1>::iterator_category _Category1;
> typedef typename iterator_traits<_II2>::iterator_category _Category2;
> typedef std::__lc_rai<_Category1, _Category2> __rai_type;
>
> __last1 = __rai_type::__newlast1(__first1, __last1,
> __first2, __last2);
> for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
> ++__first1, ++__first2)
> {
> if (*__first1 < *__first2)
> return true;
> if (*__first2 < *__first1)
> return false;
> }
> return __first1 == __last1 && __first2 != __last2;
> }
>
> template<>
> struct __lexicographical_compare<true>
> {
> template<typename _Tp, typename _Up>
> static bool
> __lc(const _Tp* __first1, const _Tp* __last1,
> const _Up* __first2, const _Up* __last2)
> {
> const size_t __len1 = __last1 - __first1;
> const size_t __len2 = __last2 - __first2;
> const int __result = __builtin_memcmp(__first1, __first2,
> std::min(__len1, __len2));
> return __result != 0 ? __result < 0 : __len1 < __len2;
> }
> };
>
> template<typename _II1, typename _II2>
> inline bool
> __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
> _II2 __first2, _II2 __last2)
> {
> typedef typename iterator_traits<_II1>::value_type _ValueType1;
> typedef typename iterator_traits<_II2>::value_type _ValueType2;
> const bool __simple =
> (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
> && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
> && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
> && __is_pointer<_II1>::__value
> && __is_pointer<_II2>::__value);
>
> return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
> __first2, __last2);
> }
># 941 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _ForwardIterator, typename _Tp>
> _ForwardIterator
> lower_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
>
>
>
>
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
> 
> 
> ;
>
> _DistanceType __len = std::distance(__first, __last);
>
> while (__len > 0)
> {
> _DistanceType __half = __len >> 1;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __half);
> if (*__middle < __val)
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else
> __len = __half;
> }
> return __first;
> }
>
>
>
> inline constexpr int
> __lg(int __n)
> { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
>
> inline constexpr unsigned
> __lg(unsigned __n)
> { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
>
> inline constexpr long
> __lg(long __n)
> { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
>
> inline constexpr unsigned long
> __lg(unsigned long __n)
> { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
>
> inline constexpr long long
> __lg(long long __n)
> { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
>
> inline constexpr unsigned long long
> __lg(unsigned long long __n)
> { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
>
>
>
>
># 1019 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _II1, typename _II2>
> inline bool
> equal(_II1 __first1, _II1 __last1, _II2 __first2)
> {
>
> 
> 
> 
>
>
> ;
>
> return std::__equal_aux(std::__niter_base(__first1),
> std::__niter_base(__last1),
> std::__niter_base(__first2));
> }
># 1051 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
> inline bool
> equal(_IIter1 __first1, _IIter1 __last1,
> _IIter2 __first2, _BinaryPredicate __binary_pred)
> {
>
> 
> 
> ;
>
> for (; __first1 != __last1; ++__first1, ++__first2)
> if (!bool(__binary_pred(*__first1, *__first2)))
> return false;
> return true;
> }
># 1082 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _II1, typename _II2>
> inline bool
> lexicographical_compare(_II1 __first1, _II1 __last1,
> _II2 __first2, _II2 __last2)
> {
>
>
>
>
>
> 
> 
> 
> 
> ;
> ;
>
> return std::__lexicographical_compare_aux(std::__niter_base(__first1),
> std::__niter_base(__last1),
> std::__niter_base(__first2),
> std::__niter_base(__last2));
> }
># 1118 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _II1, typename _II2, typename _Compare>
> bool
> lexicographical_compare(_II1 __first1, _II1 __last1,
> _II2 __first2, _II2 __last2, _Compare __comp)
> {
> typedef typename iterator_traits<_II1>::iterator_category _Category1;
> typedef typename iterator_traits<_II2>::iterator_category _Category2;
> typedef std::__lc_rai<_Category1, _Category2> __rai_type;
>
>
> 
> 
> ;
> ;
>
> __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
> for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
> ++__first1, ++__first2)
> {
> if (__comp(*__first1, *__first2))
> return true;
> if (__comp(*__first2, *__first1))
> return false;
> }
> return __first1 == __last1 && __first2 != __last2;
> }
># 1158 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2>
> pair<_InputIterator1, _InputIterator2>
> mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2)
> {
>
> 
> 
> 
>
>
> ;
>
> while (__first1 != __last1 && *__first1 == *__first2)
> {
> ++__first1;
> ++__first2;
> }
> return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
> }
># 1195 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _BinaryPredicate>
> pair<_InputIterator1, _InputIterator2>
> mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _BinaryPredicate __binary_pred)
> {
>
> 
> 
> ;
>
> while (__first1 != __last1 && bool(__binary_pred(*__first1, *__first2)))
> {
> ++__first1;
> ++__first2;
> }
> return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
> }
>
>
>}
># 40 "/usr/include/c++/4.8.2/bits/char_traits.h" 2 3
>
># 1 "/usr/include/c++/4.8.2/cwchar" 1 3
># 39 "/usr/include/c++/4.8.2/cwchar" 3
> 
># 40 "/usr/include/c++/4.8.2/cwchar" 3
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 45 "/usr/include/c++/4.8.2/cwchar" 2 3
># 42 "/usr/include/c++/4.8.2/bits/char_traits.h" 2 3
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
># 57 "/usr/include/c++/4.8.2/bits/char_traits.h" 3
> template<typename _CharT>
> struct _Char_types
> {
> typedef unsigned long int_type;
> typedef std::streampos pos_type;
> typedef std::streamoff off_type;
> typedef std::mbstate_t state_type;
> };
># 82 "/usr/include/c++/4.8.2/bits/char_traits.h" 3
> template<typename _CharT>
> struct char_traits
> {
> typedef _CharT char_type;
> typedef typename _Char_types<_CharT>::int_type int_type;
> typedef typename _Char_types<_CharT>::pos_type pos_type;
> typedef typename _Char_types<_CharT>::off_type off_type;
> typedef typename _Char_types<_CharT>::state_type state_type;
>
> static void
> assign(char_type& __c1, const char_type& __c2)
> { __c1 = __c2; }
>
> static constexpr bool
> eq(const char_type& __c1, const char_type& __c2)
> { return __c1 == __c2; }
>
> static constexpr bool
> lt(const char_type& __c1, const char_type& __c2)
> { return __c1 < __c2; }
>
> static int
> compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
>
> static std::size_t
> length(const char_type* __s);
>
> static const char_type*
> find(const char_type* __s, std::size_t __n, const char_type& __a);
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, std::size_t __n);
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, std::size_t __n);
>
> static char_type*
> assign(char_type* __s, std::size_t __n, char_type __a);
>
> static constexpr char_type
> to_char_type(const int_type& __c)
> { return static_cast<char_type>(__c); }
>
> static constexpr int_type
> to_int_type(const char_type& __c)
> { return static_cast<int_type>(__c); }
>
> static constexpr bool
> eq_int_type(const int_type& __c1, const int_type& __c2)
> { return __c1 == __c2; }
>
> static constexpr int_type
> eof()
> { return static_cast<int_type>(-1); }
>
> static constexpr int_type
> not_eof(const int_type& __c)
> { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
> };
>
> template<typename _CharT>
> int
> char_traits<_CharT>::
> compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
> {
> for (std::size_t __i = 0; __i < __n; ++__i)
> if (lt(__s1[__i], __s2[__i]))
> return -1;
> else if (lt(__s2[__i], __s1[__i]))
> return 1;
> return 0;
> }
>
> template<typename _CharT>
> std::size_t
> char_traits<_CharT>::
> length(const char_type* __p)
> {
> std::size_t __i = 0;
> while (!eq(__p[__i], char_type()))
> ++__i;
> return __i;
> }
>
> template<typename _CharT>
> const typename char_traits<_CharT>::char_type*
> char_traits<_CharT>::
> find(const char_type* __s, std::size_t __n, const char_type& __a)
> {
> for (std::size_t __i = 0; __i < __n; ++__i)
> if (eq(__s[__i], __a))
> return __s + __i;
> return 0;
> }
>
> template<typename _CharT>
> typename char_traits<_CharT>::char_type*
> char_traits<_CharT>::
> move(char_type* __s1, const char_type* __s2, std::size_t __n)
> {
> return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
> __n * sizeof(char_type)));
> }
>
> template<typename _CharT>
> typename char_traits<_CharT>::char_type*
> char_traits<_CharT>::
> copy(char_type* __s1, const char_type* __s2, std::size_t __n)
> {
>
> std::copy(__s2, __s2 + __n, __s1);
> return __s1;
> }
>
> template<typename _CharT>
> typename char_traits<_CharT>::char_type*
> char_traits<_CharT>::
> assign(char_type* __s, std::size_t __n, char_type __a)
> {
>
> std::fill_n(__s, __n, __a);
> return __s;
> }
>
>
>}
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 226 "/usr/include/c++/4.8.2/bits/char_traits.h" 3
> template<class _CharT>
> struct char_traits : public __gnu_cxx::char_traits<_CharT>
> { };
>
>
>
> template<>
> struct char_traits<char>
> {
> typedef char char_type;
> typedef int int_type;
> typedef streampos pos_type;
> typedef streamoff off_type;
> typedef mbstate_t state_type;
>
> static void
> assign(char_type& __c1, const char_type& __c2) noexcept
> { __c1 = __c2; }
>
> static constexpr bool
> eq(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr bool
> lt(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 < __c2; }
>
> static int
> compare(const char_type* __s1, const char_type* __s2, size_t __n)
> { return __builtin_memcmp(__s1, __s2, __n); }
>
> static size_t
> length(const char_type* __s)
> { return __builtin_strlen(__s); }
>
> static const char_type*
> find(const char_type* __s, size_t __n, const char_type& __a)
> { return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n)); }
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, size_t __n)
> { return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, size_t __n)
> { return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }
>
> static char_type*
> assign(char_type* __s, size_t __n, char_type __a)
> { return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }
>
> static constexpr char_type
> to_char_type(const int_type& __c) noexcept
> { return static_cast<char_type>(__c); }
>
>
>
> static constexpr int_type
> to_int_type(const char_type& __c) noexcept
> { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
>
> static constexpr bool
> eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr int_type
> eof() noexcept
> { return static_cast<int_type>(-1); }
>
> static constexpr int_type
> not_eof(const int_type& __c) noexcept
> { return (__c == eof()) ? 0 : __c; }
> };
>
>
>
>
> template<>
> struct char_traits<wchar_t>
> {
> typedef wchar_t char_type;
> typedef wint_t int_type;
> typedef streamoff off_type;
> typedef wstreampos pos_type;
> typedef mbstate_t state_type;
>
> static void
> assign(char_type& __c1, const char_type& __c2) noexcept
> { __c1 = __c2; }
>
> static constexpr bool
> eq(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr bool
> lt(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 < __c2; }
>
> static int
> compare(const char_type* __s1, const char_type* __s2, size_t __n)
> { return wmemcmp(__s1, __s2, __n); }
>
> static size_t
> length(const char_type* __s)
> { return wcslen(__s); }
>
> static const char_type*
> find(const char_type* __s, size_t __n, const char_type& __a)
> { return wmemchr(__s, __a, __n); }
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, size_t __n)
> { return wmemmove(__s1, __s2, __n); }
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, size_t __n)
> { return wmemcpy(__s1, __s2, __n); }
>
> static char_type*
> assign(char_type* __s, size_t __n, char_type __a)
> { return wmemset(__s, __a, __n); }
>
> static constexpr char_type
> to_char_type(const int_type& __c) noexcept
> { return char_type(__c); }
>
> static constexpr int_type
> to_int_type(const char_type& __c) noexcept
> { return int_type(__c); }
>
> static constexpr bool
> eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr int_type
> eof() noexcept
> { return static_cast<int_type>((0xffffffffu)); }
>
> static constexpr int_type
> not_eof(const int_type& __c) noexcept
> { return eq_int_type(__c, eof()) ? 0 : __c; }
> };
>
>
>
>}
>
>
>
>
># 1 "/usr/include/c++/4.8.2/cstdint" 1 3
># 32 "/usr/include/c++/4.8.2/cstdint" 3
> 
># 33 "/usr/include/c++/4.8.2/cstdint" 3
># 41 "/usr/include/c++/4.8.2/cstdint" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stdint.h" 1 3 4
># 9 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stdint.h" 3 4
># 1 "/usr/include/stdint.h" 1 3 4
># 27 "/usr/include/stdint.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 28 "/usr/include/stdint.h" 2 3 4
># 36 "/usr/include/stdint.h" 3 4
>typedef signed char int8_t;
>typedef short int int16_t;
>typedef int int32_t;
>
>typedef long int int64_t;
>
>
>
>
>
>
>
>typedef unsigned char uint8_t;
>typedef unsigned short int uint16_t;
>
>typedef unsigned int uint32_t;
>
>
>
>typedef unsigned long int uint64_t;
># 65 "/usr/include/stdint.h" 3 4
>typedef signed char int_least8_t;
>typedef short int int_least16_t;
>typedef int int_least32_t;
>
>typedef long int int_least64_t;
>
>
>
>
>
>
>typedef unsigned char uint_least8_t;
>typedef unsigned short int uint_least16_t;
>typedef unsigned int uint_least32_t;
>
>typedef unsigned long int uint_least64_t;
># 90 "/usr/include/stdint.h" 3 4
>typedef signed char int_fast8_t;
>
>typedef long int int_fast16_t;
>typedef long int int_fast32_t;
>typedef long int int_fast64_t;
># 103 "/usr/include/stdint.h" 3 4
>typedef unsigned char uint_fast8_t;
>
>typedef unsigned long int uint_fast16_t;
>typedef unsigned long int uint_fast32_t;
>typedef unsigned long int uint_fast64_t;
># 119 "/usr/include/stdint.h" 3 4
>typedef long int intptr_t;
>
>
>typedef unsigned long int uintptr_t;
># 134 "/usr/include/stdint.h" 3 4
>typedef long int intmax_t;
>typedef unsigned long int uintmax_t;
># 10 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stdint.h" 2 3 4
># 42 "/usr/include/c++/4.8.2/cstdint" 2 3
>
>
>
>
>namespace std
>{
> 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;
>}
># 377 "/usr/include/c++/4.8.2/bits/char_traits.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<>
> struct char_traits<char16_t>
> {
> typedef char16_t char_type;
> typedef uint_least16_t int_type;
> typedef streamoff off_type;
> typedef u16streampos pos_type;
> typedef mbstate_t state_type;
>
> static void
> assign(char_type& __c1, const char_type& __c2) noexcept
> { __c1 = __c2; }
>
> static constexpr bool
> eq(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr bool
> lt(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 < __c2; }
>
> static int
> compare(const char_type* __s1, const char_type* __s2, size_t __n)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> if (lt(__s1[__i], __s2[__i]))
> return -1;
> else if (lt(__s2[__i], __s1[__i]))
> return 1;
> return 0;
> }
>
> static size_t
> length(const char_type* __s)
> {
> size_t __i = 0;
> while (!eq(__s[__i], char_type()))
> ++__i;
> return __i;
> }
>
> static const char_type*
> find(const char_type* __s, size_t __n, const char_type& __a)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> if (eq(__s[__i], __a))
> return __s + __i;
> return 0;
> }
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, size_t __n)
> {
> return (static_cast<char_type*>
> (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
> }
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, size_t __n)
> {
> return (static_cast<char_type*>
> (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
> }
>
> static char_type*
> assign(char_type* __s, size_t __n, char_type __a)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> assign(__s[__i], __a);
> return __s;
> }
>
> static constexpr char_type
> to_char_type(const int_type& __c) noexcept
> { return char_type(__c); }
>
> static constexpr int_type
> to_int_type(const char_type& __c) noexcept
> { return int_type(__c); }
>
> static constexpr bool
> eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr int_type
> eof() noexcept
> { return static_cast<int_type>(-1); }
>
> static constexpr int_type
> not_eof(const int_type& __c) noexcept
> { return eq_int_type(__c, eof()) ? 0 : __c; }
> };
>
> template<>
> struct char_traits<char32_t>
> {
> typedef char32_t char_type;
> typedef uint_least32_t int_type;
> typedef streamoff off_type;
> typedef u32streampos pos_type;
> typedef mbstate_t state_type;
>
> static void
> assign(char_type& __c1, const char_type& __c2) noexcept
> { __c1 = __c2; }
>
> static constexpr bool
> eq(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr bool
> lt(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 < __c2; }
>
> static int
> compare(const char_type* __s1, const char_type* __s2, size_t __n)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> if (lt(__s1[__i], __s2[__i]))
> return -1;
> else if (lt(__s2[__i], __s1[__i]))
> return 1;
> return 0;
> }
>
> static size_t
> length(const char_type* __s)
> {
> size_t __i = 0;
> while (!eq(__s[__i], char_type()))
> ++__i;
> return __i;
> }
>
> static const char_type*
> find(const char_type* __s, size_t __n, const char_type& __a)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> if (eq(__s[__i], __a))
> return __s + __i;
> return 0;
> }
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, size_t __n)
> {
> return (static_cast<char_type*>
> (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
> }
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, size_t __n)
> {
> return (static_cast<char_type*>
> (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
> }
>
> static char_type*
> assign(char_type* __s, size_t __n, char_type __a)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> assign(__s[__i], __a);
> return __s;
> }
>
> static constexpr char_type
> to_char_type(const int_type& __c) noexcept
> { return char_type(__c); }
>
> static constexpr int_type
> to_int_type(const char_type& __c) noexcept
> { return int_type(__c); }
>
> static constexpr bool
> eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr int_type
> eof() noexcept
> { return static_cast<int_type>(-1); }
>
> static constexpr int_type
> not_eof(const int_type& __c) noexcept
> { return eq_int_type(__c, eof()) ? 0 : __c; }
> };
>
>
>}
># 41 "/usr/include/c++/4.8.2/ios" 2 3
># 1 "/usr/include/c++/4.8.2/bits/localefwd.h" 1 3
># 37 "/usr/include/c++/4.8.2/bits/localefwd.h" 3
> 
># 38 "/usr/include/c++/4.8.2/bits/localefwd.h" 3
>
>
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++locale.h" 1 3
># 39 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++locale.h" 3
> 
># 40 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++locale.h" 3
>
># 1 "/usr/include/c++/4.8.2/clocale" 1 3
># 39 "/usr/include/c++/4.8.2/clocale" 3
> 
># 40 "/usr/include/c++/4.8.2/clocale" 3
>
>
># 1 "/usr/include/locale.h" 1 3 4
># 28 "/usr/include/locale.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 29 "/usr/include/locale.h" 2 3 4
># 1 "/usr/include/bits/locale.h" 1 3 4
># 30 "/usr/include/locale.h" 2 3 4
>
>extern "C" {
># 50 "/usr/include/locale.h" 3 4
>
>
>
>struct lconv
>{
>
>
> char *decimal_point;
> char *thousands_sep;
>
>
>
>
>
> char *grouping;
>
>
>
>
>
> char *int_curr_symbol;
> char *currency_symbol;
> char *mon_decimal_point;
> char *mon_thousands_sep;
> char *mon_grouping;
> char *positive_sign;
> char *negative_sign;
> char int_frac_digits;
> char frac_digits;
>
> char p_cs_precedes;
>
> char p_sep_by_space;
>
> char n_cs_precedes;
>
> char n_sep_by_space;
>
>
>
>
>
>
> char p_sign_posn;
> char n_sign_posn;
>
>
> char int_p_cs_precedes;
>
> char int_p_sep_by_space;
>
> char int_n_cs_precedes;
>
> char int_n_sep_by_space;
>
>
>
>
>
>
> char int_p_sign_posn;
> char int_n_sign_posn;
># 120 "/usr/include/locale.h" 3 4
>};
>
>
>
>extern char *setlocale (int __category, const char *__locale) throw ();
>
>
>extern struct lconv *localeconv (void) throw ();
>
>
># 151 "/usr/include/locale.h" 3 4
>extern __locale_t newlocale (int __category_mask, const char *__locale,
> __locale_t __base) throw ();
># 186 "/usr/include/locale.h" 3 4
>extern __locale_t duplocale (__locale_t __dataset) throw ();
>
>
>
>extern void freelocale (__locale_t __dataset) throw ();
>
>
>
>
>
>
>extern __locale_t uselocale (__locale_t __dataset) throw ();
>
>
>
>
>
>
>
>}
># 43 "/usr/include/c++/4.8.2/clocale" 2 3
># 51 "/usr/include/c++/4.8.2/clocale" 3
>namespace std
>{
> using ::lconv;
> using ::setlocale;
> using ::localeconv;
>}
># 42 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++locale.h" 2 3
>
>
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
> extern "C" __typeof(uselocale) __uselocale;
>
>
>}
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> typedef __locale_t __c_locale;
>
>
>
>
>
> inline int
> __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
> char* __out,
> const int __size __attribute__ ((__unused__)),
> const char* __fmt, ...)
> {
>
> __c_locale __old = __gnu_cxx::__uselocale(__cloc);
># 88 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++locale.h" 3
> __builtin_va_list __args;
> __builtin_va_start(__args, __fmt);
>
>
> const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
>
>
>
>
> __builtin_va_end(__args);
>
>
> __gnu_cxx::__uselocale(__old);
>
>
>
>
>
>
>
> return __ret;
> }
>
>
>}
># 41 "/usr/include/c++/4.8.2/bits/localefwd.h" 2 3
>
># 1 "/usr/include/c++/4.8.2/cctype" 1 3
># 39 "/usr/include/c++/4.8.2/cctype" 3
> 
># 40 "/usr/include/c++/4.8.2/cctype" 3
>
>
># 1 "/usr/include/ctype.h" 1 3 4
># 26 "/usr/include/ctype.h" 3 4
># 1 "/usr/include/bits/types.h" 1 3 4
># 27 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 28 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned char __u_char;
>typedef unsigned short int __u_short;
>typedef unsigned int __u_int;
>typedef unsigned long int __u_long;
>
>
>typedef signed char __int8_t;
>typedef unsigned char __uint8_t;
>typedef signed short int __int16_t;
>typedef unsigned short int __uint16_t;
>typedef signed int __int32_t;
>typedef unsigned int __uint32_t;
>
>typedef signed long int __int64_t;
>typedef unsigned long int __uint64_t;
>
>
>
>
>
>
>
>typedef long int __quad_t;
>typedef unsigned long int __u_quad_t;
># 121 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/typesizes.h" 1 3 4
># 122 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned long int __dev_t;
>typedef unsigned int __uid_t;
>typedef unsigned int __gid_t;
>typedef unsigned long int __ino_t;
>typedef unsigned long int __ino64_t;
>typedef unsigned int __mode_t;
>typedef unsigned long int __nlink_t;
>typedef long int __off_t;
>typedef long int __off64_t;
>typedef int __pid_t;
>typedef struct { int __val[2]; } __fsid_t;
>typedef long int __clock_t;
>typedef unsigned long int __rlim_t;
>typedef unsigned long int __rlim64_t;
>typedef unsigned int __id_t;
>typedef long int __time_t;
>typedef unsigned int __useconds_t;
>typedef long int __suseconds_t;
>
>typedef int __daddr_t;
>typedef int __key_t;
>
>
>typedef int __clockid_t;
>
>
>typedef void * __timer_t;
>
>
>typedef long int __blksize_t;
>
>
>
>
>typedef long int __blkcnt_t;
>typedef long int __blkcnt64_t;
>
>
>typedef unsigned long int __fsblkcnt_t;
>typedef unsigned long int __fsblkcnt64_t;
>
>
>typedef unsigned long int __fsfilcnt_t;
>typedef unsigned long int __fsfilcnt64_t;
>
>
>typedef long int __fsword_t;
>
>typedef long int __ssize_t;
>
>
>typedef long int __syscall_slong_t;
>
>typedef unsigned long int __syscall_ulong_t;
>
>
>
>typedef __off64_t __loff_t;
>typedef __quad_t *__qaddr_t;
>typedef char *__caddr_t;
>
>
>typedef long int __intptr_t;
>
>
>typedef unsigned int __socklen_t;
># 27 "/usr/include/ctype.h" 2 3 4
>
>extern "C" {
># 39 "/usr/include/ctype.h" 3 4
># 1 "/usr/include/endian.h" 1 3 4
># 36 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/endian.h" 1 3 4
># 37 "/usr/include/endian.h" 2 3 4
># 60 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/byteswap.h" 1 3 4
># 28 "/usr/include/bits/byteswap.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/bits/byteswap.h" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/bits/byteswap-16.h" 1 3 4
># 36 "/usr/include/bits/byteswap.h" 2 3 4
># 44 "/usr/include/bits/byteswap.h" 3 4
>static __inline unsigned int
>__bswap_32 (unsigned int __bsx)
>{
> return __builtin_bswap32 (__bsx);
>}
># 108 "/usr/include/bits/byteswap.h" 3 4
>static __inline __uint64_t
>__bswap_64 (__uint64_t __bsx)
>{
> return __builtin_bswap64 (__bsx);
>}
># 61 "/usr/include/endian.h" 2 3 4
># 40 "/usr/include/ctype.h" 2 3 4
>
>
>
>
>
>
>enum
>{
> _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
> _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
> _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
> _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
> _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
> _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
> _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
> _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
> _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
> _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
> _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
> _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
>};
># 79 "/usr/include/ctype.h" 3 4
>extern const unsigned short int **__ctype_b_loc (void)
> throw () __attribute__ ((__const__));
>extern const __int32_t **__ctype_tolower_loc (void)
> throw () __attribute__ ((__const__));
>extern const __int32_t **__ctype_toupper_loc (void)
> throw () __attribute__ ((__const__));
># 104 "/usr/include/ctype.h" 3 4
>
>
>
>
>
>
>extern int isalnum (int) throw ();
>extern int isalpha (int) throw ();
>extern int iscntrl (int) throw ();
>extern int isdigit (int) throw ();
>extern int islower (int) throw ();
>extern int isgraph (int) throw ();
>extern int isprint (int) throw ();
>extern int ispunct (int) throw ();
>extern int isspace (int) throw ();
>extern int isupper (int) throw ();
>extern int isxdigit (int) throw ();
>
>
>
>extern int tolower (int __c) throw ();
>
>
>extern int toupper (int __c) throw ();
>
>
>
>
>
>
>
>
>extern int isblank (int) throw ();
>
>
>
>
>
>
>extern int isctype (int __c, int __mask) throw ();
>
>
>
>
>
>
>extern int isascii (int __c) throw ();
>
>
>
>extern int toascii (int __c) throw ();
>
>
>
>extern int _toupper (int) throw ();
>extern int _tolower (int) throw ();
># 271 "/usr/include/ctype.h" 3 4
>extern int isalnum_l (int, __locale_t) throw ();
>extern int isalpha_l (int, __locale_t) throw ();
>extern int iscntrl_l (int, __locale_t) throw ();
>extern int isdigit_l (int, __locale_t) throw ();
>extern int islower_l (int, __locale_t) throw ();
>extern int isgraph_l (int, __locale_t) throw ();
>extern int isprint_l (int, __locale_t) throw ();
>extern int ispunct_l (int, __locale_t) throw ();
>extern int isspace_l (int, __locale_t) throw ();
>extern int isupper_l (int, __locale_t) throw ();
>extern int isxdigit_l (int, __locale_t) throw ();
>
>extern int isblank_l (int, __locale_t) throw ();
>
>
>
>extern int __tolower_l (int __c, __locale_t __l) throw ();
>extern int tolower_l (int __c, __locale_t __l) throw ();
>
>
>extern int __toupper_l (int __c, __locale_t __l) throw ();
>extern int toupper_l (int __c, __locale_t __l) throw ();
># 347 "/usr/include/ctype.h" 3 4
>}
># 43 "/usr/include/c++/4.8.2/cctype" 2 3
># 62 "/usr/include/c++/4.8.2/cctype" 3
>namespace std
>{
> using ::isalnum;
> using ::isalpha;
> using ::iscntrl;
> using ::isdigit;
> using ::isgraph;
> using ::islower;
> using ::isprint;
> using ::ispunct;
> using ::isspace;
> using ::isupper;
> using ::isxdigit;
> using ::tolower;
> using ::toupper;
>}
>
>
>
>
>
>
>
>namespace std
>{
> using ::isblank;
>}
># 43 "/usr/include/c++/4.8.2/bits/localefwd.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 55 "/usr/include/c++/4.8.2/bits/localefwd.h" 3
> class locale;
>
> template<typename _Facet>
> bool
> has_facet(const locale&) throw();
>
> template<typename _Facet>
> const _Facet&
> use_facet(const locale&);
>
>
> template<typename _CharT>
> bool
> isspace(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isprint(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> iscntrl(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isupper(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> islower(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isalpha(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isdigit(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> ispunct(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isxdigit(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isalnum(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isgraph(_CharT, const locale&);
>
> template<typename _CharT>
> _CharT
> toupper(_CharT, const locale&);
>
> template<typename _CharT>
> _CharT
> tolower(_CharT, const locale&);
>
>
> class ctype_base;
> template<typename _CharT>
> class ctype;
> template<> class ctype<char>;
>
> template<> class ctype<wchar_t>;
>
> template<typename _CharT>
> class ctype_byname;
>
>
> class codecvt_base;
> template<typename _InternT, typename _ExternT, typename _StateT>
> class codecvt;
> template<> class codecvt<char, char, mbstate_t>;
>
> template<> class codecvt<wchar_t, char, mbstate_t>;
>
> template<typename _InternT, typename _ExternT, typename _StateT>
> class codecvt_byname;
>
>
>
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class num_get;
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class num_put;
>
> template<typename _CharT> class numpunct;
> template<typename _CharT> class numpunct_byname;
>
>
> template<typename _CharT>
> class collate;
> template<typename _CharT> class
> collate_byname;
>
>
> class time_base;
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class time_get;
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class time_get_byname;
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class time_put;
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class time_put_byname;
>
>
> class money_base;
>
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class money_get;
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class money_put;
>
> template<typename _CharT, bool _Intl = false>
> class moneypunct;
> template<typename _CharT, bool _Intl = false>
> class moneypunct_byname;
>
>
> class messages_base;
> template<typename _CharT>
> class messages;
> template<typename _CharT>
> class messages_byname;
>
>
>}
># 42 "/usr/include/c++/4.8.2/ios" 2 3
># 1 "/usr/include/c++/4.8.2/bits/ios_base.h" 1 3
># 37 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> 
># 38 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
>
># 1 "/usr/include/c++/4.8.2/ext/atomicity.h" 1 3
># 32 "/usr/include/c++/4.8.2/ext/atomicity.h" 3
> 
># 33 "/usr/include/c++/4.8.2/ext/atomicity.h" 3
>
>
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr.h" 1 3
># 30 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr.h" 3
>#pragma GCC visibility push(default)
># 148 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr.h" 3
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 1 3
># 35 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
># 1 "/usr/include/pthread.h" 1 3 4
># 23 "/usr/include/pthread.h" 3 4
># 1 "/usr/include/sched.h" 1 3 4
># 28 "/usr/include/sched.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 29 "/usr/include/sched.h" 2 3 4
>
>
>
># 1 "/usr/include/time.h" 1 3 4
># 73 "/usr/include/time.h" 3 4
>
>
>typedef __time_t time_t;
>
>
>
># 120 "/usr/include/time.h" 3 4
>struct timespec
> {
> __time_t tv_sec;
> __syscall_slong_t tv_nsec;
> };
># 33 "/usr/include/sched.h" 2 3 4
>
>
>typedef __pid_t pid_t;
>
>
>
>
>
># 1 "/usr/include/bits/sched.h" 1 3 4
># 72 "/usr/include/bits/sched.h" 3 4
>struct sched_param
> {
> int __sched_priority;
> };
>
>extern "C" {
>
>
>
>extern int clone (int (*__fn) (void *__arg), void *__child_stack,
> int __flags, void *__arg, ...) throw ();
>
>
>extern int unshare (int __flags) throw ();
>
>
>extern int sched_getcpu (void) throw ();
>
>
>extern int setns (int __fd, int __nstype) throw ();
>
>
>
>}
>
>
>
>
>
>
>
>struct __sched_param
> {
> int __sched_priority;
> };
># 118 "/usr/include/bits/sched.h" 3 4
>typedef unsigned long int __cpu_mask;
>
>
>
>
>
>
>typedef struct
>{
> __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
>} cpu_set_t;
># 201 "/usr/include/bits/sched.h" 3 4
>extern "C" {
>
>extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
> throw ();
>extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ;
>extern void __sched_cpufree (cpu_set_t *__set) throw ();
>
>}
># 42 "/usr/include/sched.h" 2 3 4
>
>
>
>
>extern "C" {
>
>
>extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
> throw ();
>
>
>extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
>
>
>extern int sched_setscheduler (__pid_t __pid, int __policy,
> const struct sched_param *__param) throw ();
>
>
>extern int sched_getscheduler (__pid_t __pid) throw ();
>
>
>extern int sched_yield (void) throw ();
>
>
>extern int sched_get_priority_max (int __algorithm) throw ();
>
>
>extern int sched_get_priority_min (int __algorithm) throw ();
>
>
>extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
># 116 "/usr/include/sched.h" 3 4
>extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
> const cpu_set_t *__cpuset) throw ();
>
>
>extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
> cpu_set_t *__cpuset) throw ();
>
>
>}
># 24 "/usr/include/pthread.h" 2 3 4
># 1 "/usr/include/time.h" 1 3 4
># 29 "/usr/include/time.h" 3 4
>extern "C" {
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 38 "/usr/include/time.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 30 "/usr/include/bits/time.h" 3 4
>struct timeval
> {
> __time_t tv_sec;
> __suseconds_t tv_usec;
> };
># 86 "/usr/include/bits/time.h" 3 4
># 1 "/usr/include/bits/timex.h" 1 3 4
># 25 "/usr/include/bits/timex.h" 3 4
>struct timex
>{
> unsigned int modes;
> __syscall_slong_t offset;
> __syscall_slong_t freq;
> __syscall_slong_t maxerror;
> __syscall_slong_t esterror;
> int status;
> __syscall_slong_t constant;
> __syscall_slong_t precision;
> __syscall_slong_t tolerance;
> struct timeval time;
> __syscall_slong_t tick;
> __syscall_slong_t ppsfreq;
> __syscall_slong_t jitter;
> int shift;
> __syscall_slong_t stabil;
> __syscall_slong_t jitcnt;
> __syscall_slong_t calcnt;
> __syscall_slong_t errcnt;
> __syscall_slong_t stbcnt;
>
> int tai;
>
>
> int :32; int :32; int :32; int :32;
> int :32; int :32; int :32; int :32;
> int :32; int :32; int :32;
>};
># 87 "/usr/include/bits/time.h" 2 3 4
>
>extern "C" {
>
>
>extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
>
>}
># 42 "/usr/include/time.h" 2 3 4
># 57 "/usr/include/time.h" 3 4
>
>
>typedef __clock_t clock_t;
>
>
>
># 91 "/usr/include/time.h" 3 4
>typedef __clockid_t clockid_t;
># 103 "/usr/include/time.h" 3 4
>typedef __timer_t timer_t;
># 131 "/usr/include/time.h" 3 4
>
>
>struct tm
>{
> int tm_sec;
> int tm_min;
> int tm_hour;
> int tm_mday;
> int tm_mon;
> int tm_year;
> int tm_wday;
> int tm_yday;
> int tm_isdst;
>
>
> long int tm_gmtoff;
> const char *tm_zone;
>
>
>
>
>};
>
>
>
>
>
>
>
>
>struct itimerspec
> {
> struct timespec it_interval;
> struct timespec it_value;
> };
>
>
>struct sigevent;
># 186 "/usr/include/time.h" 3 4
>
>
>
>extern clock_t clock (void) throw ();
>
>
>extern time_t time (time_t *__timer) throw ();
>
>
>extern double difftime (time_t __time1, time_t __time0)
> throw () __attribute__ ((__const__));
>
>
>extern time_t mktime (struct tm *__tp) throw ();
>
>
>
>
>
>extern size_t strftime (char *__restrict __s, size_t __maxsize,
> const char *__restrict __format,
> const struct tm *__restrict __tp) throw ();
>
>
>
>
>
>extern char *strptime (const char *__restrict __s,
> const char *__restrict __fmt, struct tm *__tp)
> throw ();
>
>
>
>
>
>
>
>extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
> const char *__restrict __format,
> const struct tm *__restrict __tp,
> __locale_t __loc) throw ();
>
>
>
>extern char *strptime_l (const char *__restrict __s,
> const char *__restrict __fmt, struct tm *__tp,
> __locale_t __loc) throw ();
>
>
>
>
>
>
>extern struct tm *gmtime (const time_t *__timer) throw ();
>
>
>
>extern struct tm *localtime (const time_t *__timer) throw ();
>
>
>
>
>
>extern struct tm *gmtime_r (const time_t *__restrict __timer,
> struct tm *__restrict __tp) throw ();
>
>
>
>extern struct tm *localtime_r (const time_t *__restrict __timer,
> struct tm *__restrict __tp) throw ();
>
>
>
>
>
>extern char *asctime (const struct tm *__tp) throw ();
>
>
>extern char *ctime (const time_t *__timer) throw ();
>
>
>
>
>
>
>
>extern char *asctime_r (const struct tm *__restrict __tp,
> char *__restrict __buf) throw ();
>
>
>extern char *ctime_r (const time_t *__restrict __timer,
> char *__restrict __buf) throw ();
>
>
>
>
>extern char *__tzname[2];
>extern int __daylight;
>extern long int __timezone;
>
>
>
>
>extern char *tzname[2];
>
>
>
>extern void tzset (void) throw ();
>
>
>
>extern int daylight;
>extern long int timezone;
>
>
>
>
>
>extern int stime (const time_t *__when) throw ();
># 319 "/usr/include/time.h" 3 4
>extern time_t timegm (struct tm *__tp) throw ();
>
>
>extern time_t timelocal (struct tm *__tp) throw ();
>
>
>extern int dysize (int __year) throw () __attribute__ ((__const__));
># 334 "/usr/include/time.h" 3 4
>extern int nanosleep (const struct timespec *__requested_time,
> struct timespec *__remaining);
>
>
>
>extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
>
>
>extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
>
>
>extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
> throw ();
>
>
>
>
>
>
>extern int clock_nanosleep (clockid_t __clock_id, int __flags,
> const struct timespec *__req,
> struct timespec *__rem);
>
>
>extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
>
>
>
>
>extern int timer_create (clockid_t __clock_id,
> struct sigevent *__restrict __evp,
> timer_t *__restrict __timerid) throw ();
>
>
>extern int timer_delete (timer_t __timerid) throw ();
>
>
>extern int timer_settime (timer_t __timerid, int __flags,
> const struct itimerspec *__restrict __value,
> struct itimerspec *__restrict __ovalue) throw ();
>
>
>extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
> throw ();
>
>
>extern int timer_getoverrun (timer_t __timerid) throw ();
>
>
>
>
>
>extern int timespec_get (struct timespec *__ts, int __base)
> throw () __attribute__ ((__nonnull__ (1)));
># 403 "/usr/include/time.h" 3 4
>extern int getdate_err;
># 412 "/usr/include/time.h" 3 4
>extern struct tm *getdate (const char *__string);
># 426 "/usr/include/time.h" 3 4
>extern int getdate_r (const char *__restrict __string,
> struct tm *__restrict __resbufp);
>
>
>}
># 25 "/usr/include/pthread.h" 2 3 4
>
># 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
># 21 "/usr/include/bits/pthreadtypes.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 22 "/usr/include/bits/pthreadtypes.h" 2 3 4
># 60 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef unsigned long int pthread_t;
>
>
>union pthread_attr_t
>{
> char __size[56];
> long int __align;
>};
>
>typedef union pthread_attr_t pthread_attr_t;
>
>
>
>
>
>typedef struct __pthread_internal_list
>{
> struct __pthread_internal_list *__prev;
> struct __pthread_internal_list *__next;
>} __pthread_list_t;
># 90 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef union
>{
> struct __pthread_mutex_s
> {
> int __lock;
> unsigned int __count;
> int __owner;
>
> unsigned int __nusers;
>
>
>
> int __kind;
>
> short __spins;
> short __elision;
> __pthread_list_t __list;
># 124 "/usr/include/bits/pthreadtypes.h" 3 4
> } __data;
> char __size[40];
> long int __align;
>} pthread_mutex_t;
>
>typedef union
>{
> char __size[4];
> int __align;
>} pthread_mutexattr_t;
>
>
>
>
>typedef union
>{
> struct
> {
> int __lock;
> unsigned int __futex;
> __extension__ unsigned long long int __total_seq;
> __extension__ unsigned long long int __wakeup_seq;
> __extension__ unsigned long long int __woken_seq;
> void *__mutex;
> unsigned int __nwaiters;
> unsigned int __broadcast_seq;
> } __data;
> char __size[48];
> __extension__ long long int __align;
>} pthread_cond_t;
>
>typedef union
>{
> char __size[4];
> int __align;
>} pthread_condattr_t;
>
>
>
>typedef unsigned int pthread_key_t;
>
>
>
>typedef int pthread_once_t;
>
>
>
>
>
>typedef union
>{
>
> struct
> {
> int __lock;
> unsigned int __nr_readers;
> unsigned int __readers_wakeup;
> unsigned int __writer_wakeup;
> unsigned int __nr_readers_queued;
> unsigned int __nr_writers_queued;
> int __writer;
> int __shared;
> unsigned long int __pad1;
> unsigned long int __pad2;
>
>
> unsigned int __flags;
>
> } __data;
># 211 "/usr/include/bits/pthreadtypes.h" 3 4
> char __size[56];
> long int __align;
>} pthread_rwlock_t;
>
>typedef union
>{
> char __size[8];
> long int __align;
>} pthread_rwlockattr_t;
>
>
>
>
>
>typedef volatile int pthread_spinlock_t;
>
>
>
>
>typedef union
>{
> char __size[32];
> long int __align;
>} pthread_barrier_t;
>
>typedef union
>{
> char __size[4];
> int __align;
>} pthread_barrierattr_t;
># 27 "/usr/include/pthread.h" 2 3 4
># 1 "/usr/include/bits/setjmp.h" 1 3 4
># 26 "/usr/include/bits/setjmp.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 27 "/usr/include/bits/setjmp.h" 2 3 4
>
>
>
>
>typedef long int __jmp_buf[8];
># 28 "/usr/include/pthread.h" 2 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/pthread.h" 2 3 4
>
>
>
>enum
>{
> PTHREAD_CREATE_JOINABLE,
>
> PTHREAD_CREATE_DETACHED
>
>};
>
>
>
>enum
>{
> PTHREAD_MUTEX_TIMED_NP,
> PTHREAD_MUTEX_RECURSIVE_NP,
> PTHREAD_MUTEX_ERRORCHECK_NP,
> PTHREAD_MUTEX_ADAPTIVE_NP
>
> ,
> PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
> PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
> PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
> PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
>
>
>
> , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
>
>};
>
>
>
>
>enum
>{
> PTHREAD_MUTEX_STALLED,
> PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
> PTHREAD_MUTEX_ROBUST,
> PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
>};
>
>
>
>
>
>enum
>{
> PTHREAD_PRIO_NONE,
> PTHREAD_PRIO_INHERIT,
> PTHREAD_PRIO_PROTECT
>};
># 125 "/usr/include/pthread.h" 3 4
>enum
>{
> PTHREAD_RWLOCK_PREFER_READER_NP,
> PTHREAD_RWLOCK_PREFER_WRITER_NP,
> PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
> PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
>};
># 166 "/usr/include/pthread.h" 3 4
>enum
>{
> PTHREAD_INHERIT_SCHED,
>
> PTHREAD_EXPLICIT_SCHED
>
>};
>
>
>
>enum
>{
> PTHREAD_SCOPE_SYSTEM,
>
> PTHREAD_SCOPE_PROCESS
>
>};
>
>
>
>enum
>{
> PTHREAD_PROCESS_PRIVATE,
>
> PTHREAD_PROCESS_SHARED
>
>};
># 201 "/usr/include/pthread.h" 3 4
>struct _pthread_cleanup_buffer
>{
> void (*__routine) (void *);
> void *__arg;
> int __canceltype;
> struct _pthread_cleanup_buffer *__prev;
>};
>
>
>enum
>{
> PTHREAD_CANCEL_ENABLE,
>
> PTHREAD_CANCEL_DISABLE
>
>};
>enum
>{
> PTHREAD_CANCEL_DEFERRED,
>
> PTHREAD_CANCEL_ASYNCHRONOUS
>
>};
># 239 "/usr/include/pthread.h" 3 4
>extern "C" {
>
>
>
>
>extern int pthread_create (pthread_t *__restrict __newthread,
> const pthread_attr_t *__restrict __attr,
> void *(*__start_routine) (void *),
> void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>
>extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>
>extern int pthread_join (pthread_t __th, void **__thread_return);
>
>
>
>
>extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
>
>
>
>
>
>
>
>extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
> const struct timespec *__abstime);
>
>
>
>
>
>
>extern int pthread_detach (pthread_t __th) throw ();
>
>
>
>extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
>
>
>extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
> throw () __attribute__ ((__const__));
>
>
>
>
>
>
>
>extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_destroy (pthread_attr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
> int *__detachstate)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
> int __detachstate)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
> size_t *__guardsize)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
> size_t __guardsize)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
> struct sched_param *__restrict __param)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
> const struct sched_param *__restrict
> __param) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
> __attr, int *__restrict __policy)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
> __attr, int *__restrict __inherit)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
> int __inherit)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
> int *__restrict __scope)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
> __attr, void **__restrict __stackaddr)
> throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
>
>
>
>
>
>extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
> void *__stackaddr)
> throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
>
>
>extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
> __attr, size_t *__restrict __stacksize)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
> size_t __stacksize)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
> void **__restrict __stackaddr,
> size_t *__restrict __stacksize)
> throw () __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
>extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
> size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
> size_t __cpusetsize,
> const cpu_set_t *__cpuset)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
> size_t __cpusetsize,
> cpu_set_t *__cpuset)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>extern int pthread_getattr_default_np (pthread_attr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>
>extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
> const struct sched_param *__param)
> throw () __attribute__ ((__nonnull__ (3)));
>
>
>extern int pthread_getschedparam (pthread_t __target_thread,
> int *__restrict __policy,
> struct sched_param *__restrict __param)
> throw () __attribute__ ((__nonnull__ (2, 3)));
>
>
>extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
> throw ();
>
>
>
>
>extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
> size_t __buflen)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int pthread_getconcurrency (void) throw ();
>
>
>extern int pthread_setconcurrency (int __level) throw ();
>
>
>
>
>
>
>
>extern int pthread_yield (void) throw ();
>
>
>
>
>extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
> const cpu_set_t *__cpuset)
> throw () __attribute__ ((__nonnull__ (3)));
>
>
>extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
> cpu_set_t *__cpuset)
> throw () __attribute__ ((__nonnull__ (3)));
># 505 "/usr/include/pthread.h" 3 4
>extern int pthread_once (pthread_once_t *__once_control,
> void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
># 517 "/usr/include/pthread.h" 3 4
>extern int pthread_setcancelstate (int __state, int *__oldstate);
>
>
>
>extern int pthread_setcanceltype (int __type, int *__oldtype);
>
>
>extern int pthread_cancel (pthread_t __th);
>
>
>
>
>extern void pthread_testcancel (void);
>
>
>
>
>typedef struct
>{
> struct
> {
> __jmp_buf __cancel_jmp_buf;
> int __mask_was_saved;
> } __cancel_jmp_buf[1];
> void *__pad[4];
>} __pthread_unwind_buf_t __attribute__ ((__aligned__));
># 551 "/usr/include/pthread.h" 3 4
>struct __pthread_cleanup_frame
>{
> void (*__cancel_routine) (void *);
> void *__cancel_arg;
> int __do_it;
> int __cancel_type;
>};
>
>
>
>
>class __pthread_cleanup_class
>{
> void (*__cancel_routine) (void *);
> void *__cancel_arg;
> int __do_it;
> int __cancel_type;
>
> public:
> __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
> : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
> ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
> void __setdoit (int __newval) { __do_it = __newval; }
> void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
> &__cancel_type); }
> void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
>};
># 753 "/usr/include/pthread.h" 3 4
>struct __jmp_buf_tag;
>extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
>
>
>
>
>
>extern int pthread_mutex_init (pthread_mutex_t *__mutex,
> const pthread_mutexattr_t *__mutexattr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
> const struct timespec *__restrict
> __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
> __restrict __mutex,
> int *__restrict __prioceiling)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
> int __prioceiling,
> int *__restrict __old_ceiling)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
>
>extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
># 817 "/usr/include/pthread.h" 3 4
>extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
> __restrict __attr,
> int *__restrict __pshared)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
> int __pshared)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
> __attr, int *__restrict __kind)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
> __restrict __attr,
> int *__restrict __protocol)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
> int __protocol)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
> __restrict __attr,
> int *__restrict __prioceiling)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
> int __prioceiling)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
> int *__robustness)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
> int *__robustness)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
> int __robustness)
> throw () __attribute__ ((__nonnull__ (1)));
>
>extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
> int __robustness)
> throw () __attribute__ ((__nonnull__ (1)));
># 899 "/usr/include/pthread.h" 3 4
>extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
> const pthread_rwlockattr_t *__restrict
> __attr) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
> const struct timespec *__restrict
> __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
> const struct timespec *__restrict
> __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
> __restrict __attr,
> int *__restrict __pshared)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
> int __pshared)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
> __restrict __attr,
> int *__restrict __pref)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
> int __pref) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
> const pthread_condattr_t *__restrict __cond_attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_destroy (pthread_cond_t *__cond)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_signal (pthread_cond_t *__cond)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_broadcast (pthread_cond_t *__cond)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
> pthread_mutex_t *__restrict __mutex)
> __attribute__ ((__nonnull__ (1, 2)));
># 1011 "/usr/include/pthread.h" 3 4
>extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
> pthread_mutex_t *__restrict __mutex,
> const struct timespec *__restrict __abstime)
> __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
>extern int pthread_condattr_init (pthread_condattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_condattr_getpshared (const pthread_condattr_t *
> __restrict __attr,
> int *__restrict __pshared)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
> int __pshared) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_condattr_getclock (const pthread_condattr_t *
> __restrict __attr,
> __clockid_t *__restrict __clock_id)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
> __clockid_t __clock_id)
> throw () __attribute__ ((__nonnull__ (1)));
># 1055 "/usr/include/pthread.h" 3 4
>extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_lock (pthread_spinlock_t *__lock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
> const pthread_barrierattr_t *__restrict
> __attr, unsigned int __count)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
> __restrict __attr,
> int *__restrict __pshared)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
> int __pshared)
> throw () __attribute__ ((__nonnull__ (1)));
># 1122 "/usr/include/pthread.h" 3 4
>extern int pthread_key_create (pthread_key_t *__key,
> void (*__destr_function) (void *))
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_key_delete (pthread_key_t __key) throw ();
>
>
>extern void *pthread_getspecific (pthread_key_t __key) throw ();
>
>
>extern int pthread_setspecific (pthread_key_t __key,
> const void *__pointer) throw () ;
>
>
>
>
>extern int pthread_getcpuclockid (pthread_t __thread_id,
> __clockid_t *__clock_id)
> throw () __attribute__ ((__nonnull__ (2)));
># 1156 "/usr/include/pthread.h" 3 4
>extern int pthread_atfork (void (*__prepare) (void),
> void (*__parent) (void),
> void (*__child) (void)) throw ();
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ()
>{
> return __thread1 == __thread2;
>}
>
>
>}
># 36 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 2 3
># 47 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
>typedef pthread_t __gthread_t;
>typedef pthread_key_t __gthread_key_t;
>typedef pthread_once_t __gthread_once_t;
>typedef pthread_mutex_t __gthread_mutex_t;
>typedef pthread_mutex_t __gthread_recursive_mutex_t;
>typedef pthread_cond_t __gthread_cond_t;
>typedef struct timespec __gthread_time_t;
># 101 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
>static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
>static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
>static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
>
>static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
>static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
>static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
>static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
>static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
>
>static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
>
>static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
>
>static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
>static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
>
>static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
>
>static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
>static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
>static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));
>
>static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init")));
>static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
>static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
>static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
>static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
>static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));
>
>static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
>static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
>static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
>static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
>static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
># 236 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
>static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create")));
># 246 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_active_p (void)
>{
> static void *const __gthread_active_ptr
> = __extension__ (void *) &__gthrw___pthread_key_create;
> return __gthread_active_ptr != 0;
>}
># 658 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
> void *__args)
>{
> return __gthrw_pthread_create (__threadid, __null, __func, __args);
>}
>
>static inline int
>__gthread_join (__gthread_t __threadid, void **__value_ptr)
>{
> return __gthrw_pthread_join (__threadid, __value_ptr);
>}
>
>static inline int
>__gthread_detach (__gthread_t __threadid)
>{
> return __gthrw_pthread_detach (__threadid);
>}
>
>static inline int
>__gthread_equal (__gthread_t __t1, __gthread_t __t2)
>{
> return __gthrw_pthread_equal (__t1, __t2);
>}
>
>static inline __gthread_t
>__gthread_self (void)
>{
> return __gthrw_pthread_self ();
>}
>
>static inline int
>__gthread_yield (void)
>{
> return __gthrw_sched_yield ();
>}
>
>static inline int
>__gthread_once (__gthread_once_t *__once, void (*__func) (void))
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_once (__once, __func);
> else
> return -1;
>}
>
>static inline int
>__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
>{
> return __gthrw_pthread_key_create (__key, __dtor);
>}
>
>static inline int
>__gthread_key_delete (__gthread_key_t __key)
>{
> return __gthrw_pthread_key_delete (__key);
>}
>
>static inline void *
>__gthread_getspecific (__gthread_key_t __key)
>{
> return __gthrw_pthread_getspecific (__key);
>}
>
>static inline int
>__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
>{
> return __gthrw_pthread_setspecific (__key, __ptr);
>}
>
>static inline void
>__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
>{
> if (__gthread_active_p ())
> __gthrw_pthread_mutex_init (__mutex, __null);
>}
>
>static inline int
>__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_mutex_destroy (__mutex);
> else
> return 0;
>}
>
>static inline int
>__gthread_mutex_lock (__gthread_mutex_t *__mutex)
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_mutex_lock (__mutex);
> else
> return 0;
>}
>
>static inline int
>__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_mutex_trylock (__mutex);
> else
> return 0;
>}
>
>
>static inline int
>__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
> const __gthread_time_t *__abs_timeout)
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
> else
> return 0;
>}
>
>
>static inline int
>__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_mutex_unlock (__mutex);
> else
> return 0;
>}
># 807 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
>{
> return __gthread_mutex_lock (__mutex);
>}
>
>static inline int
>__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
>{
> return __gthread_mutex_trylock (__mutex);
>}
>
>
>static inline int
>__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
> const __gthread_time_t *__abs_timeout)
>{
> return __gthread_mutex_timedlock (__mutex, __abs_timeout);
>}
>
>
>static inline int
>__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
>{
> return __gthread_mutex_unlock (__mutex);
>}
>
>static inline int
>__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
>{
> return __gthread_mutex_destroy (__mutex);
>}
># 849 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_cond_broadcast (__gthread_cond_t *__cond)
>{
> return __gthrw_pthread_cond_broadcast (__cond);
>}
>
>static inline int
>__gthread_cond_signal (__gthread_cond_t *__cond)
>{
> return __gthrw_pthread_cond_signal (__cond);
>}
>
>static inline int
>__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
>{
> return __gthrw_pthread_cond_wait (__cond, __mutex);
>}
>
>static inline int
>__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
> const __gthread_time_t *__abs_timeout)
>{
> return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
>}
>
>static inline int
>__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
> __gthread_recursive_mutex_t *__mutex)
>{
> return __gthread_cond_wait (__cond, __mutex);
>}
>
>static inline int
>__gthread_cond_destroy (__gthread_cond_t* __cond)
>{
> return __gthrw_pthread_cond_destroy (__cond);
>}
># 149 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr.h" 2 3
>
>
>#pragma GCC visibility pop
># 36 "/usr/include/c++/4.8.2/ext/atomicity.h" 2 3
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/atomic_word.h" 1 3
># 32 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/atomic_word.h" 3
>typedef int _Atomic_word;
># 37 "/usr/include/c++/4.8.2/ext/atomicity.h" 2 3
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> static inline _Atomic_word
> __exchange_and_add(volatile _Atomic_word* __mem, int __val)
> { return __atomic_fetch_add(__mem, __val, 4); }
>
> static inline void
> __atomic_add(volatile _Atomic_word* __mem, int __val)
> { __atomic_fetch_add(__mem, __val, 4); }
># 64 "/usr/include/c++/4.8.2/ext/atomicity.h" 3
> static inline _Atomic_word
> __exchange_and_add_single(_Atomic_word* __mem, int __val)
> {
> _Atomic_word __result = *__mem;
> *__mem += __val;
> return __result;
> }
>
> static inline void
> __atomic_add_single(_Atomic_word* __mem, int __val)
> { *__mem += __val; }
>
> static inline _Atomic_word
> __attribute__ ((__unused__))
> __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
> {
>
> if (__gthread_active_p())
> return __exchange_and_add(__mem, __val);
> else
> return __exchange_and_add_single(__mem, __val);
>
>
>
> }
>
> static inline void
> __attribute__ ((__unused__))
> __atomic_add_dispatch(_Atomic_word* __mem, int __val)
> {
>
> if (__gthread_active_p())
> __atomic_add(__mem, __val);
> else
> __atomic_add_single(__mem, __val);
>
>
>
> }
>
>
>}
># 40 "/usr/include/c++/4.8.2/bits/ios_base.h" 2 3
>
># 1 "/usr/include/c++/4.8.2/bits/locale_classes.h" 1 3
># 37 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> 
># 38 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
>
>
># 1 "/usr/include/c++/4.8.2/string" 1 3
># 36 "/usr/include/c++/4.8.2/string" 3
> 
># 37 "/usr/include/c++/4.8.2/string" 3
>
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/allocator.h" 1 3
># 46 "/usr/include/c++/4.8.2/bits/allocator.h" 3
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++allocator.h" 1 3
># 33 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++allocator.h" 3
># 1 "/usr/include/c++/4.8.2/ext/new_allocator.h" 1 3
># 33 "/usr/include/c++/4.8.2/ext/new_allocator.h" 3
># 1 "/usr/include/c++/4.8.2/new" 1 3
># 37 "/usr/include/c++/4.8.2/new" 3
> 
># 38 "/usr/include/c++/4.8.2/new" 3
>
>
>
>
>#pragma GCC visibility push(default)
>
>extern "C++" {
>
>namespace std
>{
>
>
>
>
>
>
> class bad_alloc : public exception
> {
> public:
> bad_alloc() throw() { }
>
>
>
> virtual ~bad_alloc() throw();
>
>
> virtual const char* what() const throw();
> };
>
> struct nothrow_t { };
>
> extern const nothrow_t nothrow;
>
>
>
> typedef void (*new_handler)();
>
>
>
> new_handler set_new_handler(new_handler) throw();
>}
># 91 "/usr/include/c++/4.8.2/new" 3
>void* operator new(std::size_t)
> __attribute__((__externally_visible__));
>void* operator new[](std::size_t)
> __attribute__((__externally_visible__));
>void operator delete(void*) noexcept
> __attribute__((__externally_visible__));
>void operator delete[](void*) noexcept
> __attribute__((__externally_visible__));
>void* operator new(std::size_t, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__));
>void* operator new[](std::size_t, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__));
>void operator delete(void*, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__));
>void operator delete[](void*, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__));
>
>
>inline void* operator new(std::size_t, void* __p) noexcept
>{ return __p; }
>inline void* operator new[](std::size_t, void* __p) noexcept
>{ return __p; }
>
>
>inline void operator delete (void*, void*) noexcept { }
>inline void operator delete[](void*, void*) noexcept { }
>
>}
>
>#pragma GCC visibility pop
># 34 "/usr/include/c++/4.8.2/ext/new_allocator.h" 2 3
>
>
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
> using std::size_t;
> using std::ptrdiff_t;
># 57 "/usr/include/c++/4.8.2/ext/new_allocator.h" 3
> template<typename _Tp>
> class new_allocator
> {
> public:
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Tp* pointer;
> typedef const _Tp* const_pointer;
> typedef _Tp& reference;
> typedef const _Tp& const_reference;
> typedef _Tp value_type;
>
> template<typename _Tp1>
> struct rebind
> { typedef new_allocator<_Tp1> other; };
>
>
>
>
> typedef std::true_type propagate_on_container_move_assignment;
>
>
> new_allocator() noexcept { }
>
> new_allocator(const new_allocator&) noexcept { }
>
> template<typename _Tp1>
> new_allocator(const new_allocator<_Tp1>&) noexcept { }
>
> ~new_allocator() noexcept { }
>
> pointer
> address(reference __x) const noexcept
> { return std::__addressof(__x); }
>
> const_pointer
> address(const_reference __x) const noexcept
> { return std::__addressof(__x); }
>
>
>
> pointer
> allocate(size_type __n, const void* = 0)
> {
> if (__n > this->max_size())
> std::__throw_bad_alloc();
>
> return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
> }
>
>
> void
> deallocate(pointer __p, size_type)
> { ::operator delete(__p); }
>
> size_type
> max_size() const noexcept
> { return size_t(-1) / sizeof(_Tp); }
>
>
> template<typename _Up, typename... _Args>
> void
> construct(_Up* __p, _Args&&... __args)
> { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
>
> template<typename _Up>
> void
> destroy(_Up* __p) { __p->~_Up(); }
># 135 "/usr/include/c++/4.8.2/ext/new_allocator.h" 3
> };
>
> template<typename _Tp>
> inline bool
> operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
> { return true; }
>
> template<typename _Tp>
> inline bool
> operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
> { return false; }
>
>
>}
># 34 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++allocator.h" 2 3
>
>
>namespace std
>{
># 47 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++allocator.h" 3
> template<typename _Tp>
> using __allocator_base = __gnu_cxx::new_allocator<_Tp>;
>}
># 47 "/usr/include/c++/4.8.2/bits/allocator.h" 2 3
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>
> template<>
> class allocator<void>
> {
> public:
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef void* pointer;
> typedef const void* const_pointer;
> typedef void value_type;
>
> template<typename _Tp1>
> struct rebind
> { typedef allocator<_Tp1> other; };
>
>
>
>
> typedef true_type propagate_on_container_move_assignment;
>
> };
># 91 "/usr/include/c++/4.8.2/bits/allocator.h" 3
> template<typename _Tp>
> class allocator: public __allocator_base<_Tp>
> {
> public:
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Tp* pointer;
> typedef const _Tp* const_pointer;
> typedef _Tp& reference;
> typedef const _Tp& const_reference;
> typedef _Tp value_type;
>
> template<typename _Tp1>
> struct rebind
> { typedef allocator<_Tp1> other; };
>
>
>
>
> typedef true_type propagate_on_container_move_assignment;
>
>
> allocator() throw() { }
>
> allocator(const allocator& __a) throw()
> : __allocator_base<_Tp>(__a) { }
>
> template<typename _Tp1>
> allocator(const allocator<_Tp1>&) throw() { }
>
> ~allocator() throw() { }
>
>
> };
>
> template<typename _T1, typename _T2>
> inline bool
> operator==(const allocator<_T1>&, const allocator<_T2>&)
> { return true; }
>
> template<typename _Tp>
> inline bool
> operator==(const allocator<_Tp>&, const allocator<_Tp>&)
> { return true; }
>
> template<typename _T1, typename _T2>
> inline bool
> operator!=(const allocator<_T1>&, const allocator<_T2>&)
> { return false; }
>
> template<typename _Tp>
> inline bool
> operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
> { return false; }
>
>
>
>
>
>
> extern template class allocator<char>;
> extern template class allocator<wchar_t>;
>
>
>
>
>
>
> template<typename _Alloc, bool = __is_empty(_Alloc)>
> struct __alloc_swap
> { static void _S_do_it(_Alloc&, _Alloc&) { } };
>
> template<typename _Alloc>
> struct __alloc_swap<_Alloc, false>
> {
> static void
> _S_do_it(_Alloc& __one, _Alloc& __two)
> {
>
> if (__one != __two)
> swap(__one, __two);
> }
> };
>
>
> template<typename _Alloc, bool = __is_empty(_Alloc)>
> struct __alloc_neq
> {
> static bool
> _S_do_it(const _Alloc&, const _Alloc&)
> { return false; }
> };
>
> template<typename _Alloc>
> struct __alloc_neq<_Alloc, false>
> {
> static bool
> _S_do_it(const _Alloc& __one, const _Alloc& __two)
> { return __one != __two; }
> };
>
>
> template<typename _Tp, bool
> = __or_<is_copy_constructible<typename _Tp::value_type>,
> is_nothrow_move_constructible<typename _Tp::value_type>>::value>
> struct __shrink_to_fit_aux
> { static bool _S_do_it(_Tp&) { return false; } };
>
> template<typename _Tp>
> struct __shrink_to_fit_aux<_Tp, true>
> {
> static bool
> _S_do_it(_Tp& __c)
> {
> try
> {
> _Tp(__make_move_if_noexcept_iterator(__c.begin()),
> __make_move_if_noexcept_iterator(__c.end()),
> __c.get_allocator()).swap(__c);
> return true;
> }
> catch(...)
> { return false; }
> }
> };
>
>
>
>}
># 42 "/usr/include/c++/4.8.2/string" 2 3
>
>
># 1 "/usr/include/c++/4.8.2/bits/ostream_insert.h" 1 3
># 33 "/usr/include/c++/4.8.2/bits/ostream_insert.h" 3
> 
># 34 "/usr/include/c++/4.8.2/bits/ostream_insert.h" 3
>
>
># 1 "/usr/include/c++/4.8.2/bits/cxxabi_forced.h" 1 3
># 34 "/usr/include/c++/4.8.2/bits/cxxabi_forced.h" 3
> 
># 35 "/usr/include/c++/4.8.2/bits/cxxabi_forced.h" 3
>
>#pragma GCC visibility push(default)
>
>
>namespace __cxxabiv1
>{
>
>
>
>
>
>
>
> class __forced_unwind
> {
> virtual ~__forced_unwind() throw();
>
>
> virtual void __pure_dummy() = 0;
> };
>}
>
>
>#pragma GCC visibility pop
># 37 "/usr/include/c++/4.8.2/bits/ostream_insert.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> inline void
> __ostream_write(basic_ostream<_CharT, _Traits>& __out,
> const _CharT* __s, streamsize __n)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const streamsize __put = __out.rdbuf()->sputn(__s, __n);
> if (__put != __n)
> __out.setstate(__ios_base::badbit);
> }
>
> template<typename _CharT, typename _Traits>
> inline void
> __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const _CharT __c = __out.fill();
> for (; __n > 0; --__n)
> {
> const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
> if (_Traits::eq_int_type(__put, _Traits::eof()))
> {
> __out.setstate(__ios_base::badbit);
> break;
> }
> }
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
> const _CharT* __s, streamsize __n)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> typename __ostream_type::sentry __cerb(__out);
> if (__cerb)
> {
> try
> {
> const streamsize __w = __out.width();
> if (__w > __n)
> {
> const bool __left = ((__out.flags()
> & __ios_base::adjustfield)
> == __ios_base::left);
> if (!__left)
> __ostream_fill(__out, __w - __n);
> if (__out.good())
> __ostream_write(__out, __s, __n);
> if (__left && __out.good())
> __ostream_fill(__out, __w - __n);
> }
> else
> __ostream_write(__out, __s, __n);
> __out.width(0);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __out._M_setstate(__ios_base::badbit);
> throw;
> }
> catch(...)
> { __out._M_setstate(__ios_base::badbit); }
> }
> return __out;
> }
>
>
>
>
> extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
>
>
> extern template wostream& __ostream_insert(wostream&, const wchar_t*,
> streamsize);
>
>
>
>
>}
># 45 "/usr/include/c++/4.8.2/string" 2 3
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/stl_function.h" 1 3
># 59 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 100 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
> template<typename _Arg, typename _Result>
> struct unary_function
> {
>
> typedef _Arg argument_type;
>
>
> typedef _Result result_type;
> };
>
>
>
>
> template<typename _Arg1, typename _Arg2, typename _Result>
> struct binary_function
> {
>
> typedef _Arg1 first_argument_type;
>
>
> typedef _Arg2 second_argument_type;
>
>
> typedef _Result result_type;
> };
># 139 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
> template<typename _Tp>
> struct plus : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x + __y; }
> };
>
>
> template<typename _Tp>
> struct minus : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x - __y; }
> };
>
>
> template<typename _Tp>
> struct multiplies : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x * __y; }
> };
>
>
> template<typename _Tp>
> struct divides : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x / __y; }
> };
>
>
> template<typename _Tp>
> struct modulus : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x % __y; }
> };
>
>
> template<typename _Tp>
> struct negate : public unary_function<_Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x) const
> { return -__x; }
> };
># 203 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
> template<typename _Tp>
> struct equal_to : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x == __y; }
> };
>
>
> template<typename _Tp>
> struct not_equal_to : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x != __y; }
> };
>
>
> template<typename _Tp>
> struct greater : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x > __y; }
> };
>
>
> template<typename _Tp>
> struct less : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x < __y; }
> };
>
>
> template<typename _Tp>
> struct greater_equal : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x >= __y; }
> };
>
>
> template<typename _Tp>
> struct less_equal : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x <= __y; }
> };
># 267 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
> template<typename _Tp>
> struct logical_and : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x && __y; }
> };
>
>
> template<typename _Tp>
> struct logical_or : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x || __y; }
> };
>
>
> template<typename _Tp>
> struct logical_not : public unary_function<_Tp, bool>
> {
> bool
> operator()(const _Tp& __x) const
> { return !__x; }
> };
>
>
>
>
> template<typename _Tp>
> struct bit_and : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x & __y; }
> };
>
> template<typename _Tp>
> struct bit_or : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x | __y; }
> };
>
> template<typename _Tp>
> struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x ^ __y; }
> };
># 350 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
> template<typename _Predicate>
> class unary_negate
> : public unary_function<typename _Predicate::argument_type, bool>
> {
> protected:
> _Predicate _M_pred;
>
> public:
> explicit
> unary_negate(const _Predicate& __x) : _M_pred(__x) { }
>
> bool
> operator()(const typename _Predicate::argument_type& __x) const
> { return !_M_pred(__x); }
> };
>
>
> template<typename _Predicate>
> inline unary_negate<_Predicate>
> not1(const _Predicate& __pred)
> { return unary_negate<_Predicate>(__pred); }
>
>
> template<typename _Predicate>
> class binary_negate
> : public binary_function<typename _Predicate::first_argument_type,
> typename _Predicate::second_argument_type, bool>
> {
> protected:
> _Predicate _M_pred;
>
> public:
> explicit
> binary_negate(const _Predicate& __x) : _M_pred(__x) { }
>
> bool
> operator()(const typename _Predicate::first_argument_type& __x,
> const typename _Predicate::second_argument_type& __y) const
> { return !_M_pred(__x, __y); }
> };
>
>
> template<typename _Predicate>
> inline binary_negate<_Predicate>
> not2(const _Predicate& __pred)
> { return binary_negate<_Predicate>(__pred); }
># 421 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
> template<typename _Arg, typename _Result>
> class pointer_to_unary_function : public unary_function<_Arg, _Result>
> {
> protected:
> _Result (*_M_ptr)(_Arg);
>
> public:
> pointer_to_unary_function() { }
>
> explicit
> pointer_to_unary_function(_Result (*__x)(_Arg))
> : _M_ptr(__x) { }
>
> _Result
> operator()(_Arg __x) const
> { return _M_ptr(__x); }
> };
>
>
> template<typename _Arg, typename _Result>
> inline pointer_to_unary_function<_Arg, _Result>
> ptr_fun(_Result (*__x)(_Arg))
> { return pointer_to_unary_function<_Arg, _Result>(__x); }
>
>
> template<typename _Arg1, typename _Arg2, typename _Result>
> class pointer_to_binary_function
> : public binary_function<_Arg1, _Arg2, _Result>
> {
> protected:
> _Result (*_M_ptr)(_Arg1, _Arg2);
>
> public:
> pointer_to_binary_function() { }
>
> explicit
> pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
> : _M_ptr(__x) { }
>
> _Result
> operator()(_Arg1 __x, _Arg2 __y) const
> { return _M_ptr(__x, __y); }
> };
>
>
> template<typename _Arg1, typename _Arg2, typename _Result>
> inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
> ptr_fun(_Result (*__x)(_Arg1, _Arg2))
> { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
>
>
> template<typename _Tp>
> struct _Identity
> : public unary_function<_Tp,_Tp>
> {
> _Tp&
> operator()(_Tp& __x) const
> { return __x; }
>
> const _Tp&
> operator()(const _Tp& __x) const
> { return __x; }
> };
>
> template<typename _Pair>
> struct _Select1st
> : public unary_function<_Pair, typename _Pair::first_type>
> {
> typename _Pair::first_type&
> operator()(_Pair& __x) const
> { return __x.first; }
>
> const typename _Pair::first_type&
> operator()(const _Pair& __x) const
> { return __x.first; }
>
>
> template<typename _Pair2>
> typename _Pair2::first_type&
> operator()(_Pair2& __x) const
> { return __x.first; }
>
> template<typename _Pair2>
> const typename _Pair2::first_type&
> operator()(const _Pair2& __x) const
> { return __x.first; }
>
> };
>
> template<typename _Pair>
> struct _Select2nd
> : public unary_function<_Pair, typename _Pair::second_type>
> {
> typename _Pair::second_type&
> operator()(_Pair& __x) const
> { return __x.second; }
>
> const typename _Pair::second_type&
> operator()(const _Pair& __x) const
> { return __x.second; }
> };
># 541 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
> template<typename _Ret, typename _Tp>
> class mem_fun_t : public unary_function<_Tp*, _Ret>
> {
> public:
> explicit
> mem_fun_t(_Ret (_Tp::*__pf)())
> : _M_f(__pf) { }
>
> _Ret
> operator()(_Tp* __p) const
> { return (__p->*_M_f)(); }
>
> private:
> _Ret (_Tp::*_M_f)();
> };
>
>
>
> template<typename _Ret, typename _Tp>
> class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
> {
> public:
> explicit
> const_mem_fun_t(_Ret (_Tp::*__pf)() const)
> : _M_f(__pf) { }
>
> _Ret
> operator()(const _Tp* __p) const
> { return (__p->*_M_f)(); }
>
> private:
> _Ret (_Tp::*_M_f)() const;
> };
>
>
>
> template<typename _Ret, typename _Tp>
> class mem_fun_ref_t : public unary_function<_Tp, _Ret>
> {
> public:
> explicit
> mem_fun_ref_t(_Ret (_Tp::*__pf)())
> : _M_f(__pf) { }
>
> _Ret
> operator()(_Tp& __r) const
> { return (__r.*_M_f)(); }
>
> private:
> _Ret (_Tp::*_M_f)();
> };
>
>
>
> template<typename _Ret, typename _Tp>
> class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
> {
> public:
> explicit
> const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
> : _M_f(__pf) { }
>
> _Ret
> operator()(const _Tp& __r) const
> { return (__r.*_M_f)(); }
>
> private:
> _Ret (_Tp::*_M_f)() const;
> };
>
>
>
> template<typename _Ret, typename _Tp, typename _Arg>
> class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
> {
> public:
> explicit
> mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
> : _M_f(__pf) { }
>
> _Ret
> operator()(_Tp* __p, _Arg __x) const
> { return (__p->*_M_f)(__x); }
>
> private:
> _Ret (_Tp::*_M_f)(_Arg);
> };
>
>
>
> template<typename _Ret, typename _Tp, typename _Arg>
> class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
> {
> public:
> explicit
> const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
> : _M_f(__pf) { }
>
> _Ret
> operator()(const _Tp* __p, _Arg __x) const
> { return (__p->*_M_f)(__x); }
>
> private:
> _Ret (_Tp::*_M_f)(_Arg) const;
> };
>
>
>
> template<typename _Ret, typename _Tp, typename _Arg>
> class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
> {
> public:
> explicit
> mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
> : _M_f(__pf) { }
>
> _Ret
> operator()(_Tp& __r, _Arg __x) const
> { return (__r.*_M_f)(__x); }
>
> private:
> _Ret (_Tp::*_M_f)(_Arg);
> };
>
>
>
> template<typename _Ret, typename _Tp, typename _Arg>
> class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
> {
> public:
> explicit
> const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
> : _M_f(__pf) { }
>
> _Ret
> operator()(const _Tp& __r, _Arg __x) const
> { return (__r.*_M_f)(__x); }
>
> private:
> _Ret (_Tp::*_M_f)(_Arg) const;
> };
>
>
>
> template<typename _Ret, typename _Tp>
> inline mem_fun_t<_Ret, _Tp>
> mem_fun(_Ret (_Tp::*__f)())
> { return mem_fun_t<_Ret, _Tp>(__f); }
>
> template<typename _Ret, typename _Tp>
> inline const_mem_fun_t<_Ret, _Tp>
> mem_fun(_Ret (_Tp::*__f)() const)
> { return const_mem_fun_t<_Ret, _Tp>(__f); }
>
> template<typename _Ret, typename _Tp>
> inline mem_fun_ref_t<_Ret, _Tp>
> mem_fun_ref(_Ret (_Tp::*__f)())
> { return mem_fun_ref_t<_Ret, _Tp>(__f); }
>
> template<typename _Ret, typename _Tp>
> inline const_mem_fun_ref_t<_Ret, _Tp>
> mem_fun_ref(_Ret (_Tp::*__f)() const)
> { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
>
> template<typename _Ret, typename _Tp, typename _Arg>
> inline mem_fun1_t<_Ret, _Tp, _Arg>
> mem_fun(_Ret (_Tp::*__f)(_Arg))
> { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
>
> template<typename _Ret, typename _Tp, typename _Arg>
> inline const_mem_fun1_t<_Ret, _Tp, _Arg>
> mem_fun(_Ret (_Tp::*__f)(_Arg) const)
> { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
>
> template<typename _Ret, typename _Tp, typename _Arg>
> inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
> mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
> { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
>
> template<typename _Ret, typename _Tp, typename _Arg>
> inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
> mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
> { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
>
>
>
>
>}
>
>
># 1 "/usr/include/c++/4.8.2/backward/binders.h" 1 3
># 59 "/usr/include/c++/4.8.2/backward/binders.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 103 "/usr/include/c++/4.8.2/backward/binders.h" 3
> template<typename _Operation>
> class binder1st
> : public unary_function<typename _Operation::second_argument_type,
> typename _Operation::result_type>
> {
> protected:
> _Operation op;
> typename _Operation::first_argument_type value;
>
> public:
> binder1st(const _Operation& __x,
> const typename _Operation::first_argument_type& __y)
> : op(__x), value(__y) { }
>
> typename _Operation::result_type
> operator()(const typename _Operation::second_argument_type& __x) const
> { return op(value, __x); }
>
>
>
> typename _Operation::result_type
> operator()(typename _Operation::second_argument_type& __x) const
> { return op(value, __x); }
> } __attribute__ ((__deprecated__));
>
>
> template<typename _Operation, typename _Tp>
> inline binder1st<_Operation>
> bind1st(const _Operation& __fn, const _Tp& __x)
> {
> typedef typename _Operation::first_argument_type _Arg1_type;
> return binder1st<_Operation>(__fn, _Arg1_type(__x));
> }
>
>
> template<typename _Operation>
> class binder2nd
> : public unary_function<typename _Operation::first_argument_type,
> typename _Operation::result_type>
> {
> protected:
> _Operation op;
> typename _Operation::second_argument_type value;
>
> public:
> binder2nd(const _Operation& __x,
> const typename _Operation::second_argument_type& __y)
> : op(__x), value(__y) { }
>
> typename _Operation::result_type
> operator()(const typename _Operation::first_argument_type& __x) const
> { return op(__x, value); }
>
>
>
> typename _Operation::result_type
> operator()(typename _Operation::first_argument_type& __x) const
> { return op(__x, value); }
> } __attribute__ ((__deprecated__));
>
>
> template<typename _Operation, typename _Tp>
> inline binder2nd<_Operation>
> bind2nd(const _Operation& __fn, const _Tp& __x)
> {
> typedef typename _Operation::second_argument_type _Arg2_type;
> return binder2nd<_Operation>(__fn, _Arg2_type(__x));
> }
>
>
>
>}
># 732 "/usr/include/c++/4.8.2/bits/stl_function.h" 2 3
># 49 "/usr/include/c++/4.8.2/string" 2 3
>
>
># 1 "/usr/include/c++/4.8.2/bits/range_access.h" 1 3
># 33 "/usr/include/c++/4.8.2/bits/range_access.h" 3
> 
># 34 "/usr/include/c++/4.8.2/bits/range_access.h" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> template<class _Container>
> inline auto
> begin(_Container& __cont) -> decltype(__cont.begin())
> { return __cont.begin(); }
>
>
>
>
>
>
> template<class _Container>
> inline auto
> begin(const _Container& __cont) -> decltype(__cont.begin())
> { return __cont.begin(); }
>
>
>
>
>
>
> template<class _Container>
> inline auto
> end(_Container& __cont) -> decltype(__cont.end())
> { return __cont.end(); }
>
>
>
>
>
>
> template<class _Container>
> inline auto
> end(const _Container& __cont) -> decltype(__cont.end())
> { return __cont.end(); }
>
>
>
>
>
> template<class _Tp, size_t _Nm>
> inline _Tp*
> begin(_Tp (&__arr)[_Nm])
> { return __arr; }
>
>
>
>
>
>
> template<class _Tp, size_t _Nm>
> inline _Tp*
> end(_Tp (&__arr)[_Nm])
> { return __arr + _Nm; }
>
>
>}
># 52 "/usr/include/c++/4.8.2/string" 2 3
># 1 "/usr/include/c++/4.8.2/bits/basic_string.h" 1 3
># 37 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> 
># 38 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
>
>
>
>
># 1 "/usr/include/c++/4.8.2/initializer_list" 1 3
># 33 "/usr/include/c++/4.8.2/initializer_list" 3
> 
># 34 "/usr/include/c++/4.8.2/initializer_list" 3
>
>
>
>
>
>#pragma GCC visibility push(default)
>
>
>
>namespace std
>{
>
> template<class _E>
> class initializer_list
> {
> public:
> typedef _E value_type;
> typedef const _E& reference;
> typedef const _E& const_reference;
> typedef size_t size_type;
> typedef const _E* iterator;
> typedef const _E* const_iterator;
>
> private:
> iterator _M_array;
> size_type _M_len;
>
>
> constexpr initializer_list(const_iterator __a, size_type __l)
> : _M_array(__a), _M_len(__l) { }
>
> public:
> constexpr initializer_list() noexcept
> : _M_array(0), _M_len(0) { }
>
>
> constexpr size_type
> size() const noexcept { return _M_len; }
>
>
> constexpr const_iterator
> begin() const noexcept { return _M_array; }
>
>
> constexpr const_iterator
> end() const noexcept { return begin() + size(); }
> };
>
>
>
>
>
>
> template<class _Tp>
> constexpr const _Tp*
> begin(initializer_list<_Tp> __ils) noexcept
> { return __ils.begin(); }
>
>
>
>
>
>
> template<class _Tp>
> constexpr const _Tp*
> end(initializer_list<_Tp> __ils) noexcept
> { return __ils.end(); }
>}
>
>#pragma GCC visibility pop
># 43 "/usr/include/c++/4.8.2/bits/basic_string.h" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 111 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> class basic_string
> {
> typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
>
>
> public:
> typedef _Traits traits_type;
> typedef typename _Traits::char_type value_type;
> typedef _Alloc allocator_type;
> typedef typename _CharT_alloc_type::size_type size_type;
> typedef typename _CharT_alloc_type::difference_type difference_type;
> typedef typename _CharT_alloc_type::reference reference;
> typedef typename _CharT_alloc_type::const_reference const_reference;
> typedef typename _CharT_alloc_type::pointer pointer;
> typedef typename _CharT_alloc_type::const_pointer const_pointer;
> typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
> typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
> const_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<iterator> reverse_iterator;
>
> private:
># 148 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> struct _Rep_base
> {
> size_type _M_length;
> size_type _M_capacity;
> _Atomic_word _M_refcount;
> };
>
> struct _Rep : _Rep_base
> {
>
> typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
># 173 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> static const size_type _S_max_size;
> static const _CharT _S_terminal;
>
>
>
> static size_type _S_empty_rep_storage[];
>
> static _Rep&
> _S_empty_rep()
> {
>
>
>
> void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
> return *reinterpret_cast<_Rep*>(__p);
> }
>
> bool
> _M_is_leaked() const
> { return this->_M_refcount < 0; }
>
> bool
> _M_is_shared() const
> { return this->_M_refcount > 0; }
>
> void
> _M_set_leaked()
> { this->_M_refcount = -1; }
>
> void
> _M_set_sharable()
> { this->_M_refcount = 0; }
>
> void
> _M_set_length_and_sharable(size_type __n)
> {
>
> if (__builtin_expect(this != &_S_empty_rep(), false))
>
> {
> this->_M_set_sharable();
> this->_M_length = __n;
> traits_type::assign(this->_M_refdata()[__n], _S_terminal);
>
>
> }
> }
>
> _CharT*
> _M_refdata() throw()
> { return reinterpret_cast<_CharT*>(this + 1); }
>
> _CharT*
> _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
> {
> return (!_M_is_leaked() && __alloc1 == __alloc2)
> ? _M_refcopy() : _M_clone(__alloc1);
> }
>
>
> static _Rep*
> _S_create(size_type, size_type, const _Alloc&);
>
> void
> _M_dispose(const _Alloc& __a)
> {
>
> if (__builtin_expect(this != &_S_empty_rep(), false))
>
> {
>
> ;
> if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
> -1) <= 0)
> {
> ;
> _M_destroy(__a);
> }
> }
> }
>
> void
> _M_destroy(const _Alloc&) throw();
>
> _CharT*
> _M_refcopy() throw()
> {
>
> if (__builtin_expect(this != &_S_empty_rep(), false))
>
> __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
> return _M_refdata();
> }
>
> _CharT*
> _M_clone(const _Alloc&, size_type __res = 0);
> };
>
>
> struct _Alloc_hider : _Alloc
> {
> _Alloc_hider(_CharT* __dat, const _Alloc& __a)
> : _Alloc(__a), _M_p(__dat) { }
>
> _CharT* _M_p;
> };
>
> public:
>
>
>
>
> static const size_type npos = static_cast<size_type>(-1);
>
> private:
>
> mutable _Alloc_hider _M_dataplus;
>
> _CharT*
> _M_data() const
> { return _M_dataplus._M_p; }
>
> _CharT*
> _M_data(_CharT* __p)
> { return (_M_dataplus._M_p = __p); }
>
> _Rep*
> _M_rep() const
> { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
>
>
>
> iterator
> _M_ibegin() const
> { return iterator(_M_data()); }
>
> iterator
> _M_iend() const
> { return iterator(_M_data() + this->size()); }
>
> void
> _M_leak()
> {
> if (!_M_rep()->_M_is_leaked())
> _M_leak_hard();
> }
>
> size_type
> _M_check(size_type __pos, const char* __s) const
> {
> if (__pos > this->size())
> __throw_out_of_range((__s));
> return __pos;
> }
>
> void
> _M_check_length(size_type __n1, size_type __n2, const char* __s) const
> {
> if (this->max_size() - (this->size() - __n1) < __n2)
> __throw_length_error((__s));
> }
>
>
> size_type
> _M_limit(size_type __pos, size_type __off) const
> {
> const bool __testoff = __off < this->size() - __pos;
> return __testoff ? __off : this->size() - __pos;
> }
>
>
> bool
> _M_disjunct(const _CharT* __s) const
> {
> return (less<const _CharT*>()(__s, _M_data())
> || less<const _CharT*>()(_M_data() + this->size(), __s));
> }
>
>
>
> static void
> _M_copy(_CharT* __d, const _CharT* __s, size_type __n)
> {
> if (__n == 1)
> traits_type::assign(*__d, *__s);
> else
> traits_type::copy(__d, __s, __n);
> }
>
> static void
> _M_move(_CharT* __d, const _CharT* __s, size_type __n)
> {
> if (__n == 1)
> traits_type::assign(*__d, *__s);
> else
> traits_type::move(__d, __s, __n);
> }
>
> static void
> _M_assign(_CharT* __d, size_type __n, _CharT __c)
> {
> if (__n == 1)
> traits_type::assign(*__d, __c);
> else
> traits_type::assign(__d, __n, __c);
> }
>
>
>
> template<class _Iterator>
> static void
> _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
> {
> for (; __k1 != __k2; ++__k1, ++__p)
> traits_type::assign(*__p, *__k1);
> }
>
> static void
> _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
> { _S_copy_chars(__p, __k1.base(), __k2.base()); }
>
> static void
> _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
> { _S_copy_chars(__p, __k1.base(), __k2.base()); }
>
> static void
> _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
> { _M_copy(__p, __k1, __k2 - __k1); }
>
> static void
> _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
> { _M_copy(__p, __k1, __k2 - __k1); }
>
> static int
> _S_compare(size_type __n1, size_type __n2)
> {
> const difference_type __d = difference_type(__n1 - __n2);
>
> if (__d > __gnu_cxx::__numeric_traits<int>::__max)
> return __gnu_cxx::__numeric_traits<int>::__max;
> else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
> return __gnu_cxx::__numeric_traits<int>::__min;
> else
> return int(__d);
> }
>
> void
> _M_mutate(size_type __pos, size_type __len1, size_type __len2);
>
> void
> _M_leak_hard();
>
> static _Rep&
> _S_empty_rep()
> { return _Rep::_S_empty_rep(); }
>
> public:
>
>
>
>
>
>
>
> basic_string()
>
> : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
>
>
>
>
>
>
>
> explicit
> basic_string(const _Alloc& __a);
>
>
>
>
>
>
> basic_string(const basic_string& __str);
>
>
>
>
>
>
> basic_string(const basic_string& __str, size_type __pos,
> size_type __n = npos);
>
>
>
>
>
>
>
> basic_string(const basic_string& __str, size_type __pos,
> size_type __n, const _Alloc& __a);
># 483 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string(const _CharT* __s, size_type __n,
> const _Alloc& __a = _Alloc());
>
>
>
>
>
> basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
>
>
>
>
>
>
> basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
># 507 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string(basic_string&& __str) noexcept
> : _M_dataplus(__str._M_dataplus)
> {
>
> __str._M_data(_S_empty_rep()._M_refdata());
>
>
>
> }
>
>
>
>
>
>
> basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc());
># 531 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<class _InputIterator>
> basic_string(_InputIterator __beg, _InputIterator __end,
> const _Alloc& __a = _Alloc());
>
>
>
>
> ~basic_string() noexcept
> { _M_rep()->_M_dispose(this->get_allocator()); }
>
>
>
>
>
> basic_string&
> operator=(const basic_string& __str)
> { return this->assign(__str); }
>
>
>
>
>
> basic_string&
> operator=(const _CharT* __s)
> { return this->assign(__s); }
># 564 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> operator=(_CharT __c)
> {
> this->assign(1, __c);
> return *this;
> }
># 579 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> operator=(basic_string&& __str)
> {
>
> this->swap(__str);
> return *this;
> }
>
>
>
>
>
> basic_string&
> operator=(initializer_list<_CharT> __l)
> {
> this->assign(__l.begin(), __l.size());
> return *this;
> }
>
>
>
>
>
>
>
> iterator
> begin() noexcept
> {
> _M_leak();
> return iterator(_M_data());
> }
>
>
>
>
>
> const_iterator
> begin() const noexcept
> { return const_iterator(_M_data()); }
>
>
>
>
>
> iterator
> end() noexcept
> {
> _M_leak();
> return iterator(_M_data() + this->size());
> }
>
>
>
>
>
> const_iterator
> end() const noexcept
> { return const_iterator(_M_data() + this->size()); }
>
>
>
>
>
>
> reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(this->end()); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(this->end()); }
>
>
>
>
>
>
> reverse_iterator
> rend() noexcept
> { return reverse_iterator(this->begin()); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(this->begin()); }
>
>
>
>
>
>
> const_iterator
> cbegin() const noexcept
> { return const_iterator(this->_M_data()); }
>
>
>
>
>
> const_iterator
> cend() const noexcept
> { return const_iterator(this->_M_data() + this->size()); }
>
>
>
>
>
>
> const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(this->end()); }
>
>
>
>
>
>
> const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(this->begin()); }
>
>
> public:
>
>
>
> size_type
> size() const noexcept
> { return _M_rep()->_M_length; }
>
>
>
> size_type
> length() const noexcept
> { return _M_rep()->_M_length; }
>
>
> size_type
> max_size() const noexcept
> { return _Rep::_S_max_size; }
># 739 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> void
> resize(size_type __n, _CharT __c);
># 752 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> void
> resize(size_type __n)
> { this->resize(__n, _CharT()); }
>
>
>
> void
> shrink_to_fit()
> {
> if (capacity() > size())
> {
> try
> { reserve(0); }
> catch(...)
> { }
> }
> }
>
>
>
>
>
>
> size_type
> capacity() const noexcept
> { return _M_rep()->_M_capacity; }
># 796 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> void
> reserve(size_type __res_arg = 0);
>
>
>
>
> void
> clear() noexcept
> { _M_mutate(0, this->size(), 0); }
>
>
>
>
>
> bool
> empty() const noexcept
> { return this->size() == 0; }
># 825 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> const_reference
> operator[] (size_type __pos) const
> {
> ;
> return _M_data()[__pos];
> }
># 842 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> reference
> operator[](size_type __pos)
> {
>
> ;
>
> ;
> _M_leak();
> return _M_data()[__pos];
> }
># 863 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> const_reference
> at(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range(("basic_string::at"));
> return _M_data()[__n];
> }
># 882 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> reference
> at(size_type __n)
> {
> if (__n >= size())
> __throw_out_of_range(("basic_string::at"));
> _M_leak();
> return _M_data()[__n];
> }
>
>
>
>
>
>
> reference
> front()
> { return operator[](0); }
>
>
>
>
>
> const_reference
> front() const
> { return operator[](0); }
>
>
>
>
>
> reference
> back()
> { return operator[](this->size() - 1); }
>
>
>
>
>
> const_reference
> back() const
> { return operator[](this->size() - 1); }
># 931 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> operator+=(const basic_string& __str)
> { return this->append(__str); }
>
>
>
>
>
>
> basic_string&
> operator+=(const _CharT* __s)
> { return this->append(__s); }
>
>
>
>
>
>
> basic_string&
> operator+=(_CharT __c)
> {
> this->push_back(__c);
> return *this;
> }
>
>
>
>
>
>
>
> basic_string&
> operator+=(initializer_list<_CharT> __l)
> { return this->append(__l.begin(), __l.size()); }
>
>
>
>
>
>
>
> basic_string&
> append(const basic_string& __str);
># 988 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> append(const basic_string& __str, size_type __pos, size_type __n);
>
>
>
>
>
>
>
> basic_string&
> append(const _CharT* __s, size_type __n);
>
>
>
>
>
>
> basic_string&
> append(const _CharT* __s)
> {
> ;
> return this->append(__s, traits_type::length(__s));
> }
># 1020 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> append(size_type __n, _CharT __c);
>
>
>
>
>
>
>
> basic_string&
> append(initializer_list<_CharT> __l)
> { return this->append(__l.begin(), __l.size()); }
># 1042 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<class _InputIterator>
> basic_string&
> append(_InputIterator __first, _InputIterator __last)
> { return this->replace(_M_iend(), _M_iend(), __first, __last); }
>
>
>
>
>
> void
> push_back(_CharT __c)
> {
> const size_type __len = 1 + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
> this->reserve(__len);
> traits_type::assign(_M_data()[this->size()], __c);
> _M_rep()->_M_set_length_and_sharable(__len);
> }
>
>
>
>
>
>
> basic_string&
> assign(const basic_string& __str);
># 1078 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> assign(basic_string&& __str)
> {
> this->swap(__str);
> return *this;
> }
># 1099 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> assign(const basic_string& __str, size_type __pos, size_type __n)
> { return this->assign(__str._M_data()
> + __str._M_check(__pos, "basic_string::assign"),
> __str._M_limit(__pos, __n)); }
># 1115 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> assign(const _CharT* __s, size_type __n);
># 1127 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> assign(const _CharT* __s)
> {
> ;
> return this->assign(__s, traits_type::length(__s));
> }
># 1143 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> assign(size_type __n, _CharT __c)
> { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
># 1155 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<class _InputIterator>
> basic_string&
> assign(_InputIterator __first, _InputIterator __last)
> { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
>
>
>
>
>
>
>
> basic_string&
> assign(initializer_list<_CharT> __l)
> { return this->assign(__l.begin(), __l.size()); }
># 1184 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> void
> insert(iterator __p, size_type __n, _CharT __c)
> { this->replace(__p, __p, __n, __c); }
># 1200 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<class _InputIterator>
> void
> insert(iterator __p, _InputIterator __beg, _InputIterator __end)
> { this->replace(__p, __p, __beg, __end); }
># 1212 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> void
> insert(iterator __p, initializer_list<_CharT> __l)
> {
> ;
> this->insert(__p - _M_ibegin(), __l.begin(), __l.size());
> }
># 1232 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos1, const basic_string& __str)
> { return this->insert(__pos1, __str, size_type(0), __str.size()); }
># 1254 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos1, const basic_string& __str,
> size_type __pos2, size_type __n)
> { return this->insert(__pos1, __str._M_data()
> + __str._M_check(__pos2, "basic_string::insert"),
> __str._M_limit(__pos2, __n)); }
># 1277 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos, const _CharT* __s, size_type __n);
># 1295 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos, const _CharT* __s)
> {
> ;
> return this->insert(__pos, __s, traits_type::length(__s));
> }
># 1318 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos, size_type __n, _CharT __c)
> { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
> size_type(0), __n, __c); }
># 1336 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> iterator
> insert(iterator __p, _CharT __c)
> {
> ;
> const size_type __pos = __p - _M_ibegin();
> _M_replace_aux(__pos, size_type(0), size_type(1), __c);
> _M_rep()->_M_set_leaked();
> return iterator(_M_data() + __pos);
> }
># 1361 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> erase(size_type __pos = 0, size_type __n = npos)
> {
> _M_mutate(_M_check(__pos, "basic_string::erase"),
> _M_limit(__pos, __n), size_type(0));
> return *this;
> }
># 1377 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> iterator
> erase(iterator __position)
> {
>
> ;
> const size_type __pos = __position - _M_ibegin();
> _M_mutate(__pos, size_type(1), size_type(0));
> _M_rep()->_M_set_leaked();
> return iterator(_M_data() + __pos);
> }
># 1397 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> iterator
> erase(iterator __first, iterator __last);
>
>
>
>
>
>
>
> void
> pop_back()
> { erase(size()-1, 1); }
># 1428 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos, size_type __n, const basic_string& __str)
> { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
># 1450 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos1, size_type __n1, const basic_string& __str,
> size_type __pos2, size_type __n2)
> { return this->replace(__pos1, __n1, __str._M_data()
> + __str._M_check(__pos2, "basic_string::replace"),
> __str._M_limit(__pos2, __n2)); }
># 1475 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2);
># 1495 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos, size_type __n1, const _CharT* __s)
> {
> ;
> return this->replace(__pos, __n1, __s, traits_type::length(__s));
> }
># 1519 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
> { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
> _M_limit(__pos, __n1), __n2, __c); }
># 1537 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> replace(iterator __i1, iterator __i2, const basic_string& __str)
> { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
># 1556 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
> {
>
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
> }
># 1577 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> replace(iterator __i1, iterator __i2, const _CharT* __s)
> {
> ;
> return this->replace(__i1, __i2, __s, traits_type::length(__s));
> }
># 1598 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string&
> replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
> {
>
> ;
> return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
> }
># 1621 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<class _InputIterator>
> basic_string&
> replace(iterator __i1, iterator __i2,
> _InputIterator __k1, _InputIterator __k2)
> {
> 
> ;
> ;
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
> }
>
>
>
> basic_string&
> replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
> {
>
> ;
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
> __k1, __k2 - __k1);
> }
>
> basic_string&
> replace(iterator __i1, iterator __i2,
> const _CharT* __k1, const _CharT* __k2)
> {
>
> ;
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
> __k1, __k2 - __k1);
> }
>
> basic_string&
> replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
> {
>
> ;
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
> __k1.base(), __k2 - __k1);
> }
>
> basic_string&
> replace(iterator __i1, iterator __i2,
> const_iterator __k1, const_iterator __k2)
> {
>
> ;
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
> __k1.base(), __k2 - __k1);
> }
># 1692 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string& replace(iterator __i1, iterator __i2,
> initializer_list<_CharT> __l)
> { return this->replace(__i1, __i2, __l.begin(), __l.end()); }
>
>
> private:
> template<class _Integer>
> basic_string&
> _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
> _Integer __val, __true_type)
> { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
>
> template<class _InputIterator>
> basic_string&
> _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
> _InputIterator __k2, __false_type);
>
> basic_string&
> _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
> _CharT __c);
>
> basic_string&
> _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
> size_type __n2);
>
>
>
> template<class _InIterator>
> static _CharT*
> _S_construct_aux(_InIterator __beg, _InIterator __end,
> const _Alloc& __a, __false_type)
> {
> typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
> return _S_construct(__beg, __end, __a, _Tag());
> }
>
>
>
> template<class _Integer>
> static _CharT*
> _S_construct_aux(_Integer __beg, _Integer __end,
> const _Alloc& __a, __true_type)
> { return _S_construct_aux_2(static_cast<size_type>(__beg),
> __end, __a); }
>
> static _CharT*
> _S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
> { return _S_construct(__req, __c, __a); }
>
> template<class _InIterator>
> static _CharT*
> _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
> {
> typedef typename std::__is_integer<_InIterator>::__type _Integral;
> return _S_construct_aux(__beg, __end, __a, _Integral());
> }
>
>
> template<class _InIterator>
> static _CharT*
> _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
> input_iterator_tag);
>
>
>
> template<class _FwdIterator>
> static _CharT*
> _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
> forward_iterator_tag);
>
> static _CharT*
> _S_construct(size_type __req, _CharT __c, const _Alloc& __a);
>
> public:
># 1779 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
># 1789 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> void
> swap(basic_string& __s);
># 1799 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> const _CharT*
> c_str() const noexcept
> { return _M_data(); }
>
>
>
>
>
>
>
> const _CharT*
> data() const noexcept
> { return _M_data(); }
>
>
>
>
> allocator_type
> get_allocator() const noexcept
> { return _M_dataplus; }
># 1832 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find(const _CharT* __s, size_type __pos, size_type __n) const;
># 1845 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find(const basic_string& __str, size_type __pos = 0) const
> noexcept
> { return this->find(__str.data(), __pos, __str.size()); }
># 1860 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find(const _CharT* __s, size_type __pos = 0) const
> {
> ;
> return this->find(__s, __pos, traits_type::length(__s));
> }
># 1877 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find(_CharT __c, size_type __pos = 0) const noexcept;
># 1890 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> rfind(const basic_string& __str, size_type __pos = npos) const
> noexcept
> { return this->rfind(__str.data(), __pos, __str.size()); }
># 1907 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> rfind(const _CharT* __s, size_type __pos, size_type __n) const;
># 1920 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> rfind(const _CharT* __s, size_type __pos = npos) const
> {
> ;
> return this->rfind(__s, __pos, traits_type::length(__s));
> }
># 1937 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> rfind(_CharT __c, size_type __pos = npos) const noexcept;
># 1951 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_first_of(const basic_string& __str, size_type __pos = 0) const
> noexcept
> { return this->find_first_of(__str.data(), __pos, __str.size()); }
># 1968 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
># 1981 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_first_of(const _CharT* __s, size_type __pos = 0) const
> {
> ;
> return this->find_first_of(__s, __pos, traits_type::length(__s));
> }
># 2000 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_first_of(_CharT __c, size_type __pos = 0) const noexcept
> { return this->find(__c, __pos); }
># 2015 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_last_of(const basic_string& __str, size_type __pos = npos) const
> noexcept
> { return this->find_last_of(__str.data(), __pos, __str.size()); }
># 2032 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
># 2045 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_last_of(const _CharT* __s, size_type __pos = npos) const
> {
> ;
> return this->find_last_of(__s, __pos, traits_type::length(__s));
> }
># 2064 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_last_of(_CharT __c, size_type __pos = npos) const noexcept
> { return this->rfind(__c, __pos); }
># 2078 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_first_not_of(const basic_string& __str, size_type __pos = 0) const
> noexcept
> { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
># 2095 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_first_not_of(const _CharT* __s, size_type __pos,
> size_type __n) const;
># 2109 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_first_not_of(const _CharT* __s, size_type __pos = 0) const
> {
> ;
> return this->find_first_not_of(__s, __pos, traits_type::length(__s));
> }
># 2126 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_first_not_of(_CharT __c, size_type __pos = 0) const
> noexcept;
># 2141 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_last_not_of(const basic_string& __str, size_type __pos = npos) const
> noexcept
> { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
># 2158 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_last_not_of(const _CharT* __s, size_type __pos,
> size_type __n) const;
># 2172 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_last_not_of(const _CharT* __s, size_type __pos = npos) const
> {
> ;
> return this->find_last_not_of(__s, __pos, traits_type::length(__s));
> }
># 2189 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> size_type
> find_last_not_of(_CharT __c, size_type __pos = npos) const
> noexcept;
># 2205 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> basic_string
> substr(size_type __pos = 0, size_type __n = npos) const
> { return basic_string(*this,
> _M_check(__pos, "basic_string::substr"), __n); }
># 2224 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> int
> compare(const basic_string& __str) const
> {
> const size_type __size = this->size();
> const size_type __osize = __str.size();
> const size_type __len = std::min(__size, __osize);
>
> int __r = traits_type::compare(_M_data(), __str.data(), __len);
> if (!__r)
> __r = _S_compare(__size, __osize);
> return __r;
> }
># 2256 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> int
> compare(size_type __pos, size_type __n, const basic_string& __str) const;
># 2282 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> int
> compare(size_type __pos1, size_type __n1, const basic_string& __str,
> size_type __pos2, size_type __n2) const;
># 2300 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> int
> compare(const _CharT* __s) const;
># 2324 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> int
> compare(size_type __pos, size_type __n1, const _CharT* __s) const;
># 2351 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> int
> compare(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2) const;
> };
># 2363 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>
> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> {
> basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
> __str.append(__rhs);
> return __str;
> }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT,_Traits,_Alloc>
> operator+(const _CharT* __lhs,
> const basic_string<_CharT,_Traits,_Alloc>& __rhs);
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT,_Traits,_Alloc>
> operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> {
> basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
> __str.append(__rhs);
> return __str;
> }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
> {
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
> __string_type __str(__lhs);
> __str.append(__size_type(1), __rhs);
> return __str;
> }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return std::move(__lhs.append(__rhs)); }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> basic_string<_CharT, _Traits, _Alloc>&& __rhs)
> { return std::move(__rhs.insert(0, __lhs)); }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
> basic_string<_CharT, _Traits, _Alloc>&& __rhs)
> {
> const auto __size = __lhs.size() + __rhs.size();
> const bool __cond = (__size > __lhs.capacity()
> && __size <= __rhs.capacity());
> return __cond ? std::move(__rhs.insert(0, __lhs))
> : std::move(__lhs.append(__rhs));
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(const _CharT* __lhs,
> basic_string<_CharT, _Traits, _Alloc>&& __rhs)
> { return std::move(__rhs.insert(0, __lhs)); }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(_CharT __lhs,
> basic_string<_CharT, _Traits, _Alloc>&& __rhs)
> { return std::move(__rhs.insert(0, 1, __lhs)); }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
> const _CharT* __rhs)
> { return std::move(__lhs.append(__rhs)); }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
> _CharT __rhs)
> { return std::move(__lhs.append(1, __rhs)); }
># 2484 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __lhs.compare(__rhs) == 0; }
>
> template<typename _CharT>
> inline
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
> operator==(const basic_string<_CharT>& __lhs,
> const basic_string<_CharT>& __rhs)
> { return (__lhs.size() == __rhs.size()
> && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
> __lhs.size())); }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator==(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) == 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) == 0; }
># 2530 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return !(__lhs == __rhs); }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator!=(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return !(__lhs == __rhs); }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return !(__lhs == __rhs); }
># 2567 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __lhs.compare(__rhs) < 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) < 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) > 0; }
># 2604 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __lhs.compare(__rhs) > 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) > 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) < 0; }
># 2641 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __lhs.compare(__rhs) <= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) <= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<=(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) >= 0; }
># 2678 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __lhs.compare(__rhs) >= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) >= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>=(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) <= 0; }
># 2715 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline void
> swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
> basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { __lhs.swap(__rhs); }
># 2733 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __is,
> basic_string<_CharT, _Traits, _Alloc>& __str);
>
> template<>
> basic_istream<char>&
> operator>>(basic_istream<char>& __is, basic_string<char>& __str);
># 2751 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os,
> const basic_string<_CharT, _Traits, _Alloc>& __str)
> {
>
>
> return __ostream_insert(__os, __str.data(), __str.size());
> }
># 2774 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_istream<_CharT, _Traits>&
> getline(basic_istream<_CharT, _Traits>& __is,
> basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
># 2791 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_istream<_CharT, _Traits>&
> getline(basic_istream<_CharT, _Traits>& __is,
> basic_string<_CharT, _Traits, _Alloc>& __str)
> { return getline(__is, __str, __is.widen('\n')); }
>
> template<>
> basic_istream<char>&
> getline(basic_istream<char>& __in, basic_string<char>& __str,
> char __delim);
>
>
> template<>
> basic_istream<wchar_t>&
> getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
> wchar_t __delim);
>
>
>
>}
>
>
>
>
># 1 "/usr/include/c++/4.8.2/ext/string_conversions.h" 1 3
># 32 "/usr/include/c++/4.8.2/ext/string_conversions.h" 3
> 
># 33 "/usr/include/c++/4.8.2/ext/string_conversions.h" 3
># 41 "/usr/include/c++/4.8.2/ext/string_conversions.h" 3
># 1 "/usr/include/c++/4.8.2/cstdlib" 1 3
># 39 "/usr/include/c++/4.8.2/cstdlib" 3
> 
># 40 "/usr/include/c++/4.8.2/cstdlib" 3
># 72 "/usr/include/c++/4.8.2/cstdlib" 3
># 1 "/usr/include/stdlib.h" 1 3 4
># 32 "/usr/include/stdlib.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 33 "/usr/include/stdlib.h" 2 3 4
>
>extern "C" {
>
>
>
>
>
>
># 1 "/usr/include/bits/waitflags.h" 1 3 4
># 42 "/usr/include/stdlib.h" 2 3 4
># 1 "/usr/include/bits/waitstatus.h" 1 3 4
># 66 "/usr/include/bits/waitstatus.h" 3 4
>union wait
> {
> int w_status;
> struct
> {
>
> unsigned int __w_termsig:7;
> unsigned int __w_coredump:1;
> unsigned int __w_retcode:8;
> unsigned int:16;
>
>
>
>
>
>
>
> } __wait_terminated;
> struct
> {
>
> unsigned int __w_stopval:8;
> unsigned int __w_stopsig:8;
> unsigned int:16;
>
>
>
>
>
>
> } __wait_stopped;
> };
># 43 "/usr/include/stdlib.h" 2 3 4
># 95 "/usr/include/stdlib.h" 3 4
>
>
>typedef struct
> {
> int quot;
> int rem;
> } div_t;
>
>
>
>typedef struct
> {
> long int quot;
> long int rem;
> } ldiv_t;
>
>
>
>
>
>
>
>__extension__ typedef struct
> {
> long long int quot;
> long long int rem;
> } lldiv_t;
>
>
># 139 "/usr/include/stdlib.h" 3 4
>extern size_t __ctype_get_mb_cur_max (void) throw () ;
>
>
>
>
>extern double atof (const char *__nptr)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern int atoi (const char *__nptr)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern long int atol (const char *__nptr)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>__extension__ extern long long int atoll (const char *__nptr)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern double strtod (const char *__restrict __nptr,
> char **__restrict __endptr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern float strtof (const char *__restrict __nptr,
> char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
>
>extern long double strtold (const char *__restrict __nptr,
> char **__restrict __endptr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern long int strtol (const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1)));
>
>extern unsigned long int strtoul (const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>__extension__
>extern long long int strtoq (const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1)));
>
>__extension__
>extern unsigned long long int strtouq (const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>__extension__
>extern long long int strtoll (const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1)));
>
>__extension__
>extern unsigned long long int strtoull (const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1)));
>
># 239 "/usr/include/stdlib.h" 3 4
>extern long int strtol_l (const char *__restrict __nptr,
> char **__restrict __endptr, int __base,
> __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));
>
>extern unsigned long int strtoul_l (const char *__restrict __nptr,
> char **__restrict __endptr,
> int __base, __locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 4)));
>
>__extension__
>extern long long int strtoll_l (const char *__restrict __nptr,
> char **__restrict __endptr, int __base,
> __locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 4)));
>
>__extension__
>extern unsigned long long int strtoull_l (const char *__restrict __nptr,
> char **__restrict __endptr,
> int __base, __locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 4)));
>
>extern double strtod_l (const char *__restrict __nptr,
> char **__restrict __endptr, __locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>extern float strtof_l (const char *__restrict __nptr,
> char **__restrict __endptr, __locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>extern long double strtold_l (const char *__restrict __nptr,
> char **__restrict __endptr,
> __locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) atoi (const char *__nptr) throw ()
>{
> return (int) strtol (__nptr, (char **) __null, 10);
>}
>extern __inline __attribute__ ((__gnu_inline__)) long int
>__attribute__ ((__leaf__)) atol (const char *__nptr) throw ()
>{
> return strtol (__nptr, (char **) __null, 10);
>}
>
>
>
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int
>__attribute__ ((__leaf__)) atoll (const char *__nptr) throw ()
>{
> return strtoll (__nptr, (char **) __null, 10);
>}
>
># 305 "/usr/include/stdlib.h" 3 4
>extern char *l64a (long int __n) throw () ;
>
>
>extern long int a64l (const char *__s)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
># 1 "/usr/include/sys/types.h" 1 3 4
># 27 "/usr/include/sys/types.h" 3 4
>extern "C" {
>
>
>
>
>
>typedef __u_char u_char;
>typedef __u_short u_short;
>typedef __u_int u_int;
>typedef __u_long u_long;
>typedef __quad_t quad_t;
>typedef __u_quad_t u_quad_t;
>typedef __fsid_t fsid_t;
>
>
>
>
>typedef __loff_t loff_t;
>
>
>
>typedef __ino_t ino_t;
>
>
>
>
>
>
>typedef __ino64_t ino64_t;
>
>
>
>
>typedef __dev_t dev_t;
>
>
>
>
>typedef __gid_t gid_t;
>
>
>
>
>typedef __mode_t mode_t;
>
>
>
>
>typedef __nlink_t nlink_t;
>
>
>
>
>typedef __uid_t uid_t;
>
>
>
>
>
>typedef __off_t off_t;
>
>
>
>
>
>
>typedef __off64_t off64_t;
># 104 "/usr/include/sys/types.h" 3 4
>typedef __id_t id_t;
>
>
>
>
>typedef __ssize_t ssize_t;
>
>
>
>
>
>typedef __daddr_t daddr_t;
>typedef __caddr_t caddr_t;
>
>
>
>
>
>typedef __key_t key_t;
># 136 "/usr/include/sys/types.h" 3 4
>typedef __useconds_t useconds_t;
>
>
>
>typedef __suseconds_t suseconds_t;
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 147 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef unsigned long int ulong;
>typedef unsigned short int ushort;
>typedef unsigned int uint;
># 200 "/usr/include/sys/types.h" 3 4
>typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
>typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
>
>typedef int register_t __attribute__ ((__mode__ (__word__)));
># 219 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/sys/select.h" 1 3 4
># 30 "/usr/include/sys/select.h" 3 4
># 1 "/usr/include/bits/select.h" 1 3 4
># 22 "/usr/include/bits/select.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 23 "/usr/include/bits/select.h" 2 3 4
># 31 "/usr/include/sys/select.h" 2 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 22 "/usr/include/bits/sigset.h" 3 4
>typedef int __sig_atomic_t;
>
>
>
>
>typedef struct
> {
> unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
> } __sigset_t;
># 34 "/usr/include/sys/select.h" 2 3 4
>
>
>
>typedef __sigset_t sigset_t;
>
>
>
>
>
>
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 46 "/usr/include/sys/select.h" 2 3 4
># 54 "/usr/include/sys/select.h" 3 4
>typedef long int __fd_mask;
># 64 "/usr/include/sys/select.h" 3 4
>typedef struct
> {
>
>
>
> __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
>
>
>
>
>
> } fd_set;
>
>
>
>
>
>
>typedef __fd_mask fd_mask;
># 96 "/usr/include/sys/select.h" 3 4
>extern "C" {
># 106 "/usr/include/sys/select.h" 3 4
>extern int select (int __nfds, fd_set *__restrict __readfds,
> fd_set *__restrict __writefds,
> fd_set *__restrict __exceptfds,
> struct timeval *__restrict __timeout);
># 118 "/usr/include/sys/select.h" 3 4
>extern int pselect (int __nfds, fd_set *__restrict __readfds,
> fd_set *__restrict __writefds,
> fd_set *__restrict __exceptfds,
> const struct timespec *__restrict __timeout,
> const __sigset_t *__restrict __sigmask);
># 131 "/usr/include/sys/select.h" 3 4
>}
># 220 "/usr/include/sys/types.h" 2 3 4
>
>
># 1 "/usr/include/sys/sysmacros.h" 1 3 4
># 24 "/usr/include/sys/sysmacros.h" 3 4
>extern "C" {
>
>__extension__
>extern unsigned int gnu_dev_major (unsigned long long int __dev)
> throw () __attribute__ ((__const__));
>__extension__
>extern unsigned int gnu_dev_minor (unsigned long long int __dev)
> throw () __attribute__ ((__const__));
>__extension__
>extern unsigned long long int gnu_dev_makedev (unsigned int __major,
> unsigned int __minor)
> throw () __attribute__ ((__const__));
>
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned int
>__attribute__ ((__leaf__)) gnu_dev_major (unsigned long long int __dev) throw ()
>{
> return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
>}
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned int
>__attribute__ ((__leaf__)) gnu_dev_minor (unsigned long long int __dev) throw ()
>{
> return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
>}
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned long long int
>__attribute__ ((__leaf__)) gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw ()
>{
> return ((__minor & 0xff) | ((__major & 0xfff) << 8)
> | (((unsigned long long int) (__minor & ~0xff)) << 12)
> | (((unsigned long long int) (__major & ~0xfff)) << 32));
>}
>
>}
># 223 "/usr/include/sys/types.h" 2 3 4
>
>
>
>
>
>typedef __blksize_t blksize_t;
>
>
>
>
>
>
>typedef __blkcnt_t blkcnt_t;
>
>
>
>typedef __fsblkcnt_t fsblkcnt_t;
>
>
>
>typedef __fsfilcnt_t fsfilcnt_t;
># 262 "/usr/include/sys/types.h" 3 4
>typedef __blkcnt64_t blkcnt64_t;
>typedef __fsblkcnt64_t fsblkcnt64_t;
>typedef __fsfilcnt64_t fsfilcnt64_t;
># 273 "/usr/include/sys/types.h" 3 4
>}
># 315 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>
>extern long int random (void) throw ();
>
>
>extern void srandom (unsigned int __seed) throw ();
>
>
>
>
>
>extern char *initstate (unsigned int __seed, char *__statebuf,
> size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>struct random_data
> {
> int32_t *fptr;
> int32_t *rptr;
> int32_t *state;
> int rand_type;
> int rand_deg;
> int rand_sep;
> int32_t *end_ptr;
> };
>
>extern int random_r (struct random_data *__restrict __buf,
> int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern int srandom_r (unsigned int __seed, struct random_data *__buf)
> throw () __attribute__ ((__nonnull__ (2)));
>
>extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
> size_t __statelen,
> struct random_data *__restrict __buf)
> throw () __attribute__ ((__nonnull__ (2, 4)));
>
>extern int setstate_r (char *__restrict __statebuf,
> struct random_data *__restrict __buf)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int rand (void) throw ();
>
>extern void srand (unsigned int __seed) throw ();
>
>
>
>
>extern int rand_r (unsigned int *__seed) throw ();
>
>
>
>
>
>
>
>extern double drand48 (void) throw ();
>extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern long int lrand48 (void) throw ();
>extern long int nrand48 (unsigned short int __xsubi[3])
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern long int mrand48 (void) throw ();
>extern long int jrand48 (unsigned short int __xsubi[3])
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern void srand48 (long int __seedval) throw ();
>extern unsigned short int *seed48 (unsigned short int __seed16v[3])
> throw () __attribute__ ((__nonnull__ (1)));
>extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>struct drand48_data
> {
> unsigned short int __x[3];
> unsigned short int __old_x[3];
> unsigned short int __c;
> unsigned short int __init;
> __extension__ unsigned long long int __a;
>
> };
>
>
>extern int drand48_r (struct drand48_data *__restrict __buffer,
> double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
>extern int erand48_r (unsigned short int __xsubi[3],
> struct drand48_data *__restrict __buffer,
> double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int lrand48_r (struct drand48_data *__restrict __buffer,
> long int *__restrict __result)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>extern int nrand48_r (unsigned short int __xsubi[3],
> struct drand48_data *__restrict __buffer,
> long int *__restrict __result)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int mrand48_r (struct drand48_data *__restrict __buffer,
> long int *__restrict __result)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>extern int jrand48_r (unsigned short int __xsubi[3],
> struct drand48_data *__restrict __buffer,
> long int *__restrict __result)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
> throw () __attribute__ ((__nonnull__ (2)));
>
>extern int seed48_r (unsigned short int __seed16v[3],
> struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern int lcong48_r (unsigned short int __param[7],
> struct drand48_data *__buffer)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>
>
>
>extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
>
>extern void *calloc (size_t __nmemb, size_t __size)
> throw () __attribute__ ((__malloc__)) ;
>
>
>
>
>
>
>
>
>
>
>extern void *realloc (void *__ptr, size_t __size)
> throw () __attribute__ ((__warn_unused_result__));
>
>extern void free (void *__ptr) throw ();
>
>
>
>
>extern void cfree (void *__ptr) throw ();
>
>
>
># 1 "/usr/include/alloca.h" 1 3 4
># 24 "/usr/include/alloca.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 25 "/usr/include/alloca.h" 2 3 4
>
>extern "C" {
>
>
>
>
>
>extern void *alloca (size_t __size) throw ();
>
>
>
>
>
>}
># 493 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
>
>
>
>
>extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>extern void *aligned_alloc (size_t __alignment, size_t __size)
> throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
>
>
>
>
>extern void abort (void) throw () __attribute__ ((__noreturn__));
>
>
>
>extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern "C++" int at_quick_exit (void (*__func) (void))
> throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>
>
>extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern void exit (int __status) throw () __attribute__ ((__noreturn__));
>
>
>
>
>
>extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
>
>
>
>
>
>
>
>extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
>
>
>
>
>
>
>extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern char *secure_getenv (const char *__name)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int setenv (const char *__name, const char *__value, int __replace)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int clearenv (void) throw ();
># 606 "/usr/include/stdlib.h" 3 4
>extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
># 620 "/usr/include/stdlib.h" 3 4
>extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
># 630 "/usr/include/stdlib.h" 3 4
>extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
># 642 "/usr/include/stdlib.h" 3 4
>extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
># 652 "/usr/include/stdlib.h" 3 4
>extern int mkstemps64 (char *__template, int __suffixlen)
> __attribute__ ((__nonnull__ (1))) ;
># 663 "/usr/include/stdlib.h" 3 4
>extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
># 674 "/usr/include/stdlib.h" 3 4
>extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
># 684 "/usr/include/stdlib.h" 3 4
>extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
># 694 "/usr/include/stdlib.h" 3 4
>extern int mkostemps (char *__template, int __suffixlen, int __flags)
> __attribute__ ((__nonnull__ (1))) ;
># 706 "/usr/include/stdlib.h" 3 4
>extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
> __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>
>
>
>extern int system (const char *__command) ;
>
>
>
>
>
>
>extern char *canonicalize_file_name (const char *__name)
> throw () __attribute__ ((__nonnull__ (1))) ;
># 734 "/usr/include/stdlib.h" 3 4
>extern char *realpath (const char *__restrict __name,
> char *__restrict __resolved) throw () ;
>
>
>
>
>
>
>typedef int (*__compar_fn_t) (const void *, const void *);
>
>
>typedef __compar_fn_t comparison_fn_t;
>
>
>
>typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
>
>
>
>
>
>extern void *bsearch (const void *__key, const void *__base,
> size_t __nmemb, size_t __size, __compar_fn_t __compar)
> __attribute__ ((__nonnull__ (1, 2, 5))) ;
>
>
># 1 "/usr/include/bits/stdlib-bsearch.h" 1 3 4
># 19 "/usr/include/bits/stdlib-bsearch.h" 3 4
>extern __inline __attribute__ ((__gnu_inline__)) void *
>bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size,
> __compar_fn_t __compar)
>{
> size_t __l, __u, __idx;
> const void *__p;
> int __comparison;
>
> __l = 0;
> __u = __nmemb;
> while (__l < __u)
> {
> __idx = (__l + __u) / 2;
> __p = (void *) (((const char *) __base) + (__idx * __size));
> __comparison = (*__compar) (__key, __p);
> if (__comparison < 0)
> __u = __idx;
> else if (__comparison > 0)
> __l = __idx + 1;
> else
> return (void *) __p;
> }
>
> return __null;
>}
># 761 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>extern void qsort (void *__base, size_t __nmemb, size_t __size,
> __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
>
>extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
> __compar_d_fn_t __compar, void *__arg)
> __attribute__ ((__nonnull__ (1, 4)));
>
>
>
>
>extern int abs (int __x) throw () __attribute__ ((__const__)) ;
>extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
>
>
>
>__extension__ extern long long int llabs (long long int __x)
> throw () __attribute__ ((__const__)) ;
>
>
>
>
>
>
>
>extern div_t div (int __numer, int __denom)
> throw () __attribute__ ((__const__)) ;
>extern ldiv_t ldiv (long int __numer, long int __denom)
> throw () __attribute__ ((__const__)) ;
>
>
>
>
>__extension__ extern lldiv_t lldiv (long long int __numer,
> long long int __denom)
> throw () __attribute__ ((__const__)) ;
>
># 812 "/usr/include/stdlib.h" 3 4
>extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
> int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
>
>
>
>
>extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
> int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
>
>
>
>
>extern char *gcvt (double __value, int __ndigit, char *__buf)
> throw () __attribute__ ((__nonnull__ (3))) ;
>
>
>
>
>extern char *qecvt (long double __value, int __ndigit,
> int *__restrict __decpt, int *__restrict __sign)
> throw () __attribute__ ((__nonnull__ (3, 4))) ;
>extern char *qfcvt (long double __value, int __ndigit,
> int *__restrict __decpt, int *__restrict __sign)
> throw () __attribute__ ((__nonnull__ (3, 4))) ;
>extern char *qgcvt (long double __value, int __ndigit, char *__buf)
> throw () __attribute__ ((__nonnull__ (3))) ;
>
>
>
>
>extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
> int *__restrict __sign, char *__restrict __buf,
> size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
> int *__restrict __sign, char *__restrict __buf,
> size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>
>extern int qecvt_r (long double __value, int __ndigit,
> int *__restrict __decpt, int *__restrict __sign,
> char *__restrict __buf, size_t __len)
> throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int qfcvt_r (long double __value, int __ndigit,
> int *__restrict __decpt, int *__restrict __sign,
> char *__restrict __buf, size_t __len)
> throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>
>
>
>
>
>
>extern int mblen (const char *__s, size_t __n) throw ();
>
>
>extern int mbtowc (wchar_t *__restrict __pwc,
> const char *__restrict __s, size_t __n) throw ();
>
>
>extern int wctomb (char *__s, wchar_t __wchar) throw ();
>
>
>
>extern size_t mbstowcs (wchar_t *__restrict __pwcs,
> const char *__restrict __s, size_t __n) throw ();
>
>extern size_t wcstombs (char *__restrict __s,
> const wchar_t *__restrict __pwcs, size_t __n)
> throw ();
>
>
>
>
>
>
>
>
>extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
># 899 "/usr/include/stdlib.h" 3 4
>extern int getsubopt (char **__restrict __optionp,
> char *const *__restrict __tokens,
> char **__restrict __valuep)
> throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;
>
>
>
>
>
>extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int posix_openpt (int __oflag) ;
>
>
>
>
>
>
>
>extern int grantpt (int __fd) throw ();
>
>
>
>extern int unlockpt (int __fd) throw ();
>
>
>
>
>extern char *ptsname (int __fd) throw () ;
>
>
>
>
>
>
>extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>extern int getpt (void);
>
>
>
>
>
>
>extern int getloadavg (double __loadavg[], int __nelem)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
># 1 "/usr/include/bits/stdlib-float.h" 1 3 4
># 24 "/usr/include/bits/stdlib-float.h" 3 4
>
>extern __inline __attribute__ ((__gnu_inline__)) double
>__attribute__ ((__leaf__)) atof (const char *__nptr) throw ()
>{
> return strtod (__nptr, (char **) __null);
>}
>
># 956 "/usr/include/stdlib.h" 2 3 4
># 968 "/usr/include/stdlib.h" 3 4
>}
># 73 "/usr/include/c++/4.8.2/cstdlib" 2 3
># 114 "/usr/include/c++/4.8.2/cstdlib" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> using ::div_t;
> using ::ldiv_t;
>
> using ::abort;
> using ::abs;
> using ::atexit;
>
>
> using ::at_quick_exit;
>
>
> using ::atof;
> using ::atoi;
> using ::atol;
> using ::bsearch;
> using ::calloc;
> using ::div;
> using ::exit;
> using ::free;
> using ::getenv;
> using ::labs;
> using ::ldiv;
> using ::malloc;
>
> using ::mblen;
> using ::mbstowcs;
> using ::mbtowc;
>
> using ::qsort;
>
>
> using ::quick_exit;
>
>
> using ::rand;
> using ::realloc;
> using ::srand;
> using ::strtod;
> using ::strtol;
> using ::strtoul;
> using ::system;
>
> using ::wcstombs;
> using ::wctomb;
>
>
>
> inline long
> abs(long __i) { return __builtin_labs(__i); }
>
> inline ldiv_t
> div(long __i, long __j) { return ldiv(__i, __j); }
>
>
>
> inline long long
> abs(long long __x) { return __builtin_llabs (__x); }
>
>
>
>
>
>
>
>
>}
># 196 "/usr/include/c++/4.8.2/cstdlib" 3
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> using ::lldiv_t;
>
>
>
>
>
> using ::_Exit;
>
>
>
> using ::llabs;
>
> inline lldiv_t
> div(long long __n, long long __d)
> { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
>
> using ::lldiv;
># 228 "/usr/include/c++/4.8.2/cstdlib" 3
> using ::atoll;
> using ::strtoll;
> using ::strtoull;
>
> using ::strtof;
> using ::strtold;
>
>
>}
>
>namespace std
>{
>
> using ::__gnu_cxx::lldiv_t;
>
> using ::__gnu_cxx::_Exit;
>
> using ::__gnu_cxx::llabs;
> using ::__gnu_cxx::div;
> using ::__gnu_cxx::lldiv;
>
> using ::__gnu_cxx::atoll;
> using ::__gnu_cxx::strtof;
> using ::__gnu_cxx::strtoll;
> using ::__gnu_cxx::strtoull;
> using ::__gnu_cxx::strtold;
>}
># 42 "/usr/include/c++/4.8.2/ext/string_conversions.h" 2 3
># 1 "/usr/include/c++/4.8.2/cwchar" 1 3
># 39 "/usr/include/c++/4.8.2/cwchar" 3
> 
># 40 "/usr/include/c++/4.8.2/cwchar" 3
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 45 "/usr/include/c++/4.8.2/cwchar" 2 3
># 43 "/usr/include/c++/4.8.2/ext/string_conversions.h" 2 3
># 1 "/usr/include/c++/4.8.2/cstdio" 1 3
># 39 "/usr/include/c++/4.8.2/cstdio" 3
> 
># 40 "/usr/include/c++/4.8.2/cstdio" 3
>
>
># 1 "/usr/include/stdio.h" 1 3 4
># 29 "/usr/include/stdio.h" 3 4
>extern "C" {
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 34 "/usr/include/stdio.h" 2 3 4
># 74 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/libio.h" 1 3 4
># 31 "/usr/include/libio.h" 3 4
># 1 "/usr/include/_G_config.h" 1 3 4
># 15 "/usr/include/_G_config.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 16 "/usr/include/_G_config.h" 2 3 4
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 21 "/usr/include/_G_config.h" 2 3 4
>typedef struct
>{
> __off_t __pos;
> __mbstate_t __state;
>} _G_fpos_t;
>typedef struct
>{
> __off64_t __pos;
> __mbstate_t __state;
>} _G_fpos64_t;
># 32 "/usr/include/libio.h" 2 3 4
># 49 "/usr/include/libio.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stdarg.h" 1 3 4
># 50 "/usr/include/libio.h" 2 3 4
># 144 "/usr/include/libio.h" 3 4
>struct _IO_jump_t; struct _IO_FILE;
># 154 "/usr/include/libio.h" 3 4
>typedef void _IO_lock_t;
>
>
>
>
>
>struct _IO_marker {
> struct _IO_marker *_next;
> struct _IO_FILE *_sbuf;
>
>
>
> int _pos;
># 177 "/usr/include/libio.h" 3 4
>};
>
>
>enum __codecvt_result
>{
> __codecvt_ok,
> __codecvt_partial,
> __codecvt_error,
> __codecvt_noconv
>};
># 245 "/usr/include/libio.h" 3 4
>struct _IO_FILE {
> int _flags;
>
>
>
>
> char* _IO_read_ptr;
> char* _IO_read_end;
> char* _IO_read_base;
> char* _IO_write_base;
> char* _IO_write_ptr;
> char* _IO_write_end;
> char* _IO_buf_base;
> char* _IO_buf_end;
>
> char *_IO_save_base;
> char *_IO_backup_base;
> char *_IO_save_end;
>
> struct _IO_marker *_markers;
>
> struct _IO_FILE *_chain;
>
> int _fileno;
>
>
>
> int _flags2;
>
> __off_t _old_offset;
>
>
>
> unsigned short _cur_column;
> signed char _vtable_offset;
> char _shortbuf[1];
>
>
>
> _IO_lock_t *_lock;
># 293 "/usr/include/libio.h" 3 4
> __off64_t _offset;
># 302 "/usr/include/libio.h" 3 4
> void *__pad1;
> void *__pad2;
> void *__pad3;
> void *__pad4;
> size_t __pad5;
>
> int _mode;
>
> char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
>
>};
>
>
>
>
>
>struct _IO_FILE_plus;
>
>extern struct _IO_FILE_plus _IO_2_1_stdin_;
>extern struct _IO_FILE_plus _IO_2_1_stdout_;
>extern struct _IO_FILE_plus _IO_2_1_stderr_;
># 338 "/usr/include/libio.h" 3 4
>typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
>
>
>
>
>
>
>
>typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
> size_t __n);
>
>
>
>
>
>
>
>typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
>
>
>typedef int __io_close_fn (void *__cookie);
>
>
>
>
>typedef __io_read_fn cookie_read_function_t;
>typedef __io_write_fn cookie_write_function_t;
>typedef __io_seek_fn cookie_seek_function_t;
>typedef __io_close_fn cookie_close_function_t;
>
>
>typedef struct
>{
> __io_read_fn *read;
> __io_write_fn *write;
> __io_seek_fn *seek;
> __io_close_fn *close;
>} _IO_cookie_io_functions_t;
>typedef _IO_cookie_io_functions_t cookie_io_functions_t;
>
>struct _IO_cookie_file;
>
>
>extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
> void *__cookie, _IO_cookie_io_functions_t __fns);
>
>
>
>
>extern "C" {
>
>
>extern int __underflow (_IO_FILE *);
>extern int __uflow (_IO_FILE *);
>extern int __overflow (_IO_FILE *, int);
># 434 "/usr/include/libio.h" 3 4
>extern int _IO_getc (_IO_FILE *__fp);
>extern int _IO_putc (int __c, _IO_FILE *__fp);
>extern int _IO_feof (_IO_FILE *__fp) throw ();
>extern int _IO_ferror (_IO_FILE *__fp) throw ();
>
>extern int _IO_peekc_locked (_IO_FILE *__fp);
>
>
>
>
>
>extern void _IO_flockfile (_IO_FILE *) throw ();
>extern void _IO_funlockfile (_IO_FILE *) throw ();
>extern int _IO_ftrylockfile (_IO_FILE *) throw ();
># 464 "/usr/include/libio.h" 3 4
>extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
> __gnuc_va_list, int *__restrict);
>extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
> __gnuc_va_list);
>extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
>extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
>
>extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
>extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
>
>extern void _IO_free_backup_area (_IO_FILE *) throw ();
># 526 "/usr/include/libio.h" 3 4
>}
># 75 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>typedef __gnuc_va_list va_list;
># 108 "/usr/include/stdio.h" 3 4
>
>
>typedef _G_fpos_t fpos_t;
>
>
>
>
>
>typedef _G_fpos64_t fpos64_t;
># 164 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 165 "/usr/include/stdio.h" 2 3 4
>
>
>
>extern struct _IO_FILE *stdin;
>extern struct _IO_FILE *stdout;
>extern struct _IO_FILE *stderr;
>
>
>
>
>
>
>
>extern int remove (const char *__filename) throw ();
>
>extern int rename (const char *__old, const char *__new) throw ();
>
>
>
>
>extern int renameat (int __oldfd, const char *__old, int __newfd,
> const char *__new) throw ();
>
>
>
>
>
>
>
>
>extern FILE *tmpfile (void) ;
># 205 "/usr/include/stdio.h" 3 4
>extern FILE *tmpfile64 (void) ;
>
>
>
>extern char *tmpnam (char *__s) throw () ;
>
>
>
>
>
>extern char *tmpnam_r (char *__s) throw () ;
># 227 "/usr/include/stdio.h" 3 4
>extern char *tempnam (const char *__dir, const char *__pfx)
> throw () __attribute__ ((__malloc__)) ;
>
>
>
>
>
>
>
>
>extern int fclose (FILE *__stream);
>
>
>
>
>extern int fflush (FILE *__stream);
>
># 252 "/usr/include/stdio.h" 3 4
>extern int fflush_unlocked (FILE *__stream);
># 262 "/usr/include/stdio.h" 3 4
>extern int fcloseall (void);
>
>
>
>
>
>
>
>
>
>extern FILE *fopen (const char *__restrict __filename,
> const char *__restrict __modes) ;
>
>
>
>
>extern FILE *freopen (const char *__restrict __filename,
> const char *__restrict __modes,
> FILE *__restrict __stream) ;
># 295 "/usr/include/stdio.h" 3 4
>
>
>extern FILE *fopen64 (const char *__restrict __filename,
> const char *__restrict __modes) ;
>extern FILE *freopen64 (const char *__restrict __filename,
> const char *__restrict __modes,
> FILE *__restrict __stream) ;
>
>
>
>
>extern FILE *fdopen (int __fd, const char *__modes) throw () ;
>
>
>
>
>
>extern FILE *fopencookie (void *__restrict __magic_cookie,
> const char *__restrict __modes,
> _IO_cookie_io_functions_t __io_funcs) throw () ;
>
>
>
>
>extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
> throw () ;
>
>
>
>
>extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
>
>
>
>
>
>
>extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
>
>
>
>extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
> int __modes, size_t __n) throw ();
>
>
>
>
>
>extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
> size_t __size) throw ();
>
>
>extern void setlinebuf (FILE *__stream) throw ();
>
>
>
>
>
>
>
>
>extern int fprintf (FILE *__restrict __stream,
> const char *__restrict __format, ...);
>
>
>
>
>extern int printf (const char *__restrict __format, ...);
>
>extern int sprintf (char *__restrict __s,
> const char *__restrict __format, ...) throw ();
>
>
>
>
>
>extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
> __gnuc_va_list __arg);
>
>
>
>
>extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
>
>extern int vsprintf (char *__restrict __s, const char *__restrict __format,
> __gnuc_va_list __arg) throw ();
>
>
>
>
>
>extern int snprintf (char *__restrict __s, size_t __maxlen,
> const char *__restrict __format, ...)
> throw () __attribute__ ((__format__ (__printf__, 3, 4)));
>
>extern int vsnprintf (char *__restrict __s, size_t __maxlen,
> const char *__restrict __format, __gnuc_va_list __arg)
> throw () __attribute__ ((__format__ (__printf__, 3, 0)));
>
>
>
>
>
>
>extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
> __gnuc_va_list __arg)
> throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
>extern int __asprintf (char **__restrict __ptr,
> const char *__restrict __fmt, ...)
> throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
>extern int asprintf (char **__restrict __ptr,
> const char *__restrict __fmt, ...)
> throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
>
>
>
>
>extern int vdprintf (int __fd, const char *__restrict __fmt,
> __gnuc_va_list __arg)
> __attribute__ ((__format__ (__printf__, 2, 0)));
>extern int dprintf (int __fd, const char *__restrict __fmt, ...)
> __attribute__ ((__format__ (__printf__, 2, 3)));
>
>
>
>
>
>
>
>
>extern int fscanf (FILE *__restrict __stream,
> const char *__restrict __format, ...) ;
>
>
>
>
>extern int scanf (const char *__restrict __format, ...) ;
>
>extern int sscanf (const char *__restrict __s,
> const char *__restrict __format, ...) throw ();
># 463 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>
>
>extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
> __gnuc_va_list __arg)
> __attribute__ ((__format__ (__scanf__, 2, 0))) ;
>
>
>
>
>
>extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
> __attribute__ ((__format__ (__scanf__, 1, 0))) ;
>
>
>extern int vsscanf (const char *__restrict __s,
> const char *__restrict __format, __gnuc_va_list __arg)
> throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
># 522 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>
>
>
>extern int fgetc (FILE *__stream);
>extern int getc (FILE *__stream);
>
>
>
>
>
>extern int getchar (void);
>
># 550 "/usr/include/stdio.h" 3 4
>extern int getc_unlocked (FILE *__stream);
>extern int getchar_unlocked (void);
># 561 "/usr/include/stdio.h" 3 4
>extern int fgetc_unlocked (FILE *__stream);
>
>
>
>
>
>
>
>
>
>
>
>extern int fputc (int __c, FILE *__stream);
>extern int putc (int __c, FILE *__stream);
>
>
>
>
>
>extern int putchar (int __c);
>
># 594 "/usr/include/stdio.h" 3 4
>extern int fputc_unlocked (int __c, FILE *__stream);
>
>
>
>
>
>
>
>extern int putc_unlocked (int __c, FILE *__stream);
>extern int putchar_unlocked (int __c);
>
>
>
>
>
>
>extern int getw (FILE *__stream);
>
>
>extern int putw (int __w, FILE *__stream);
>
>
>
>
>
>
>
>
>extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
> ;
># 638 "/usr/include/stdio.h" 3 4
>extern char *gets (char *__s) __attribute__ ((__deprecated__));
>
>
># 649 "/usr/include/stdio.h" 3 4
>extern char *fgets_unlocked (char *__restrict __s, int __n,
> FILE *__restrict __stream) ;
># 665 "/usr/include/stdio.h" 3 4
>extern __ssize_t __getdelim (char **__restrict __lineptr,
> size_t *__restrict __n, int __delimiter,
> FILE *__restrict __stream) ;
>extern __ssize_t getdelim (char **__restrict __lineptr,
> size_t *__restrict __n, int __delimiter,
> FILE *__restrict __stream) ;
>
>
>
>
>
>
>
>extern __ssize_t getline (char **__restrict __lineptr,
> size_t *__restrict __n,
> FILE *__restrict __stream) ;
>
>
>
>
>
>
>
>
>extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
>
>
>
>
>
>extern int puts (const char *__s);
>
>
>
>
>
>
>extern int ungetc (int __c, FILE *__stream);
>
>
>
>
>
>
>extern size_t fread (void *__restrict __ptr, size_t __size,
> size_t __n, FILE *__restrict __stream) ;
>
>
>
>
>extern size_t fwrite (const void *__restrict __ptr, size_t __size,
> size_t __n, FILE *__restrict __s);
>
># 726 "/usr/include/stdio.h" 3 4
>extern int fputs_unlocked (const char *__restrict __s,
> FILE *__restrict __stream);
># 737 "/usr/include/stdio.h" 3 4
>extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
> size_t __n, FILE *__restrict __stream) ;
>extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
> size_t __n, FILE *__restrict __stream);
>
>
>
>
>
>
>
>
>extern int fseek (FILE *__stream, long int __off, int __whence);
>
>
>
>
>extern long int ftell (FILE *__stream) ;
>
>
>
>
>extern void rewind (FILE *__stream);
>
># 773 "/usr/include/stdio.h" 3 4
>extern int fseeko (FILE *__stream, __off_t __off, int __whence);
>
>
>
>
>extern __off_t ftello (FILE *__stream) ;
># 792 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
>
>
>
>
>extern int fsetpos (FILE *__stream, const fpos_t *__pos);
># 815 "/usr/include/stdio.h" 3 4
>
>
>
>extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
>extern __off64_t ftello64 (FILE *__stream) ;
>extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
>extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
>
>
>
>
>extern void clearerr (FILE *__stream) throw ();
>
>extern int feof (FILE *__stream) throw () ;
>
>extern int ferror (FILE *__stream) throw () ;
>
>
>
>
>extern void clearerr_unlocked (FILE *__stream) throw ();
>extern int feof_unlocked (FILE *__stream) throw () ;
>extern int ferror_unlocked (FILE *__stream) throw () ;
>
>
>
>
>
>
>
>
>extern void perror (const char *__s);
>
>
>
>
>
>
># 1 "/usr/include/bits/sys_errlist.h" 1 3 4
># 26 "/usr/include/bits/sys_errlist.h" 3 4
>extern int sys_nerr;
>extern const char *const sys_errlist[];
>
>
>extern int _sys_nerr;
>extern const char *const _sys_errlist[];
># 854 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>extern int fileno (FILE *__stream) throw () ;
>
>
>
>
>extern int fileno_unlocked (FILE *__stream) throw () ;
># 873 "/usr/include/stdio.h" 3 4
>extern FILE *popen (const char *__command, const char *__modes) ;
>
>
>
>
>
>extern int pclose (FILE *__stream);
>
>
>
>
>
>extern char *ctermid (char *__s) throw ();
>
>
>
>
>
>extern char *cuserid (char *__s);
>
>
>
>
>struct obstack;
>
>
>extern int obstack_printf (struct obstack *__restrict __obstack,
> const char *__restrict __format, ...)
> throw () __attribute__ ((__format__ (__printf__, 2, 3)));
>extern int obstack_vprintf (struct obstack *__restrict __obstack,
> const char *__restrict __format,
> __gnuc_va_list __args)
> throw () __attribute__ ((__format__ (__printf__, 2, 0)));
>
>
>
>
>
>
>
>extern void flockfile (FILE *__stream) throw ();
>
>
>
>extern int ftrylockfile (FILE *__stream) throw () ;
>
>
>extern void funlockfile (FILE *__stream) throw ();
># 934 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio.h" 1 3 4
># 35 "/usr/include/bits/stdio.h" 3 4
>extern __inline __attribute__ ((__gnu_inline__)) int
>vprintf (const char *__restrict __fmt, __gnuc_va_list __arg)
>{
> return vfprintf (stdout, __fmt, __arg);
>}
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>getchar (void)
>{
> return _IO_getc (stdin);
>}
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>fgetc_unlocked (FILE *__fp)
>{
> return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>getc_unlocked (FILE *__fp)
>{
> return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>getchar_unlocked (void)
>{
> return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
>}
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>putchar (int __c)
>{
> return _IO_putc (__c, stdout);
>}
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>fputc_unlocked (int __c, FILE *__stream)
>{
> return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>putc_unlocked (int __c, FILE *__stream)
>{
> return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>putchar_unlocked (int __c)
>{
> return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) __ssize_t
>getline (char **__lineptr, size_t *__n, FILE *__stream)
>{
> return __getdelim (__lineptr, __n, '\n', __stream);
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) feof_unlocked (FILE *__stream) throw ()
>{
> return (((__stream)->_flags & 0x10) != 0);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) ferror_unlocked (FILE *__stream) throw ()
>{
> return (((__stream)->_flags & 0x20) != 0);
>}
># 935 "/usr/include/stdio.h" 2 3 4
># 943 "/usr/include/stdio.h" 3 4
>}
># 43 "/usr/include/c++/4.8.2/cstdio" 2 3
># 94 "/usr/include/c++/4.8.2/cstdio" 3
>namespace std
>{
> using ::FILE;
> using ::fpos_t;
>
> using ::clearerr;
> using ::fclose;
> using ::feof;
> using ::ferror;
> using ::fflush;
> using ::fgetc;
> using ::fgetpos;
> using ::fgets;
> using ::fopen;
> using ::fprintf;
> using ::fputc;
> using ::fputs;
> using ::fread;
> using ::freopen;
> using ::fscanf;
> using ::fseek;
> using ::fsetpos;
> using ::ftell;
> using ::fwrite;
> using ::getc;
> using ::getchar;
> using ::gets;
> using ::perror;
> using ::printf;
> using ::putc;
> using ::putchar;
> using ::puts;
> using ::remove;
> using ::rename;
> using ::rewind;
> using ::scanf;
> using ::setbuf;
> using ::setvbuf;
> using ::sprintf;
> using ::sscanf;
> using ::tmpfile;
> using ::tmpnam;
> using ::ungetc;
> using ::vfprintf;
> using ::vprintf;
> using ::vsprintf;
>}
># 150 "/usr/include/c++/4.8.2/cstdio" 3
>namespace __gnu_cxx
>{
># 168 "/usr/include/c++/4.8.2/cstdio" 3
> using ::snprintf;
> using ::vfscanf;
> using ::vscanf;
> using ::vsnprintf;
> using ::vsscanf;
>
>}
>
>namespace std
>{
> using ::__gnu_cxx::snprintf;
> using ::__gnu_cxx::vfscanf;
> using ::__gnu_cxx::vscanf;
> using ::__gnu_cxx::vsnprintf;
> using ::__gnu_cxx::vsscanf;
>}
># 44 "/usr/include/c++/4.8.2/ext/string_conversions.h" 2 3
># 1 "/usr/include/c++/4.8.2/cerrno" 1 3
># 39 "/usr/include/c++/4.8.2/cerrno" 3
> 
># 40 "/usr/include/c++/4.8.2/cerrno" 3
>
># 1 "/usr/include/errno.h" 1 3 4
># 31 "/usr/include/errno.h" 3 4
>extern "C" {
>
>
>
># 1 "/usr/include/bits/errno.h" 1 3 4
># 24 "/usr/include/bits/errno.h" 3 4
># 1 "/usr/include/linux/errno.h" 1 3 4
># 1 "/usr/include/asm/errno.h" 1 3 4
># 1 "/usr/include/asm-generic/errno.h" 1 3 4
>
>
>
># 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
># 5 "/usr/include/asm-generic/errno.h" 2 3 4
># 1 "/usr/include/asm/errno.h" 2 3 4
># 1 "/usr/include/linux/errno.h" 2 3 4
># 25 "/usr/include/bits/errno.h" 2 3 4
># 50 "/usr/include/bits/errno.h" 3 4
>extern int *__errno_location (void) throw () __attribute__ ((__const__));
># 36 "/usr/include/errno.h" 2 3 4
># 54 "/usr/include/errno.h" 3 4
>extern char *program_invocation_name, *program_invocation_short_name;
>
>
>
>}
># 68 "/usr/include/errno.h" 3 4
>typedef int error_t;
># 42 "/usr/include/c++/4.8.2/cerrno" 2 3
># 45 "/usr/include/c++/4.8.2/ext/string_conversions.h" 2 3
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _TRet, typename _Ret = _TRet, typename _CharT,
> typename... _Base>
> _Ret
> __stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...),
> const char* __name, const _CharT* __str, std::size_t* __idx,
> _Base... __base)
> {
> _Ret __ret;
>
> _CharT* __endptr;
> (*__errno_location ()) = 0;
> const _TRet __tmp = __convf(__str, &__endptr, __base...);
>
> if (__endptr == __str)
> std::__throw_invalid_argument(__name);
> else if ((*__errno_location ()) == 34
> || (std::__are_same<_Ret, int>::__value
> && (__tmp < __numeric_traits<int>::__min
> || __tmp > __numeric_traits<int>::__max)))
> std::__throw_out_of_range(__name);
> else
> __ret = __tmp;
>
> if (__idx)
> *__idx = __endptr - __str;
>
> return __ret;
> }
>
>
> template<typename _String, typename _CharT = typename _String::value_type>
> _String
> __to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*,
> __builtin_va_list), std::size_t __n,
> const _CharT* __fmt, ...)
> {
>
>
> _CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __n));
>
> __builtin_va_list __args;
> __builtin_va_start(__args, __fmt);
>
> const int __len = __convf(__s, __n, __fmt, __args);
>
> __builtin_va_end(__args);
>
> return _String(__s, __s + __len);
> }
>
>
>}
># 2816 "/usr/include/c++/4.8.2/bits/basic_string.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> inline int
> stoi(const string& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
> __idx, __base); }
>
> inline long
> stol(const string& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
> __idx, __base); }
>
> inline unsigned long
> stoul(const string& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
> __idx, __base); }
>
> inline long long
> stoll(const string& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
> __idx, __base); }
>
> inline unsigned long long
> stoull(const string& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
> __idx, __base); }
>
>
> inline float
> stof(const string& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
>
> inline double
> stod(const string& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
>
> inline long double
> stold(const string& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
>
>
>
>
> inline string
> to_string(int __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(int),
> "%d", __val); }
>
> inline string
> to_string(unsigned __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
> 4 * sizeof(unsigned),
> "%u", __val); }
>
> inline string
> to_string(long __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(long),
> "%ld", __val); }
>
> inline string
> to_string(unsigned long __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
> 4 * sizeof(unsigned long),
> "%lu", __val); }
>
> inline string
> to_string(long long __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
> 4 * sizeof(long long),
> "%lld", __val); }
>
> inline string
> to_string(unsigned long long __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
> 4 * sizeof(unsigned long long),
> "%llu", __val); }
>
> inline string
> to_string(float __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
> "%f", __val);
> }
>
> inline string
> to_string(double __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
> "%f", __val);
> }
>
> inline string
> to_string(long double __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
> "%Lf", __val);
> }
>
>
> inline int
> stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
> __idx, __base); }
>
> inline long
> stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
> __idx, __base); }
>
> inline unsigned long
> stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
> __idx, __base); }
>
> inline long long
> stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
> __idx, __base); }
>
> inline unsigned long long
> stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
> __idx, __base); }
>
>
> inline float
> stof(const wstring& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
>
> inline double
> stod(const wstring& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
>
> inline long double
> stold(const wstring& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
>
>
> inline wstring
> to_wstring(int __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
> L"%d", __val); }
>
> inline wstring
> to_wstring(unsigned __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
> 4 * sizeof(unsigned),
> L"%u", __val); }
>
> inline wstring
> to_wstring(long __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
> L"%ld", __val); }
>
> inline wstring
> to_wstring(unsigned long __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
> 4 * sizeof(unsigned long),
> L"%lu", __val); }
>
> inline wstring
> to_wstring(long long __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
> 4 * sizeof(long long),
> L"%lld", __val); }
>
> inline wstring
> to_wstring(unsigned long long __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
> 4 * sizeof(unsigned long long),
> L"%llu", __val); }
>
> inline wstring
> to_wstring(float __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
> L"%f", __val);
> }
>
> inline wstring
> to_wstring(double __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
> L"%f", __val);
> }
>
> inline wstring
> to_wstring(long double __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
> L"%Lf", __val);
> }
>
>
>
>}
>
>
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/functional_hash.h" 1 3
># 33 "/usr/include/c++/4.8.2/bits/functional_hash.h" 3
> 
># 34 "/usr/include/c++/4.8.2/bits/functional_hash.h" 3
>
># 1 "/usr/include/c++/4.8.2/bits/hash_bytes.h" 1 3
># 33 "/usr/include/c++/4.8.2/bits/hash_bytes.h" 3
> 
># 34 "/usr/include/c++/4.8.2/bits/hash_bytes.h" 3
>
>
>
>namespace std
>{
>
>
>
>
>
>
>
> size_t
> _Hash_bytes(const void* __ptr, size_t __len, size_t __seed);
>
>
>
>
>
> size_t
> _Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);
>
>
>}
># 36 "/usr/include/c++/4.8.2/bits/functional_hash.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 49 "/usr/include/c++/4.8.2/bits/functional_hash.h" 3
> template<typename _Result, typename _Arg>
> struct __hash_base
> {
> typedef _Result result_type;
> typedef _Arg argument_type;
> };
>
>
> template<typename _Tp>
> struct hash;
>
>
> template<typename _Tp>
> struct hash<_Tp*> : public __hash_base<size_t, _Tp*>
> {
> size_t
> operator()(_Tp* __p) const noexcept
> { return reinterpret_cast<size_t>(__p); }
> };
># 80 "/usr/include/c++/4.8.2/bits/functional_hash.h" 3
> template<> struct hash<bool> : public __hash_base<size_t, bool> { size_t operator()(bool __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<char> : public __hash_base<size_t, char> { size_t operator()(char __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<signed char> : public __hash_base<size_t, signed char> { size_t operator()(signed char __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<unsigned char> : public __hash_base<size_t, unsigned char> { size_t operator()(unsigned char __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<wchar_t> : public __hash_base<size_t, wchar_t> { size_t operator()(wchar_t __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<char16_t> : public __hash_base<size_t, char16_t> { size_t operator()(char16_t __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<char32_t> : public __hash_base<size_t, char32_t> { size_t operator()(char32_t __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<short> : public __hash_base<size_t, short> { size_t operator()(short __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<int> : public __hash_base<size_t, int> { size_t operator()(int __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<long> : public __hash_base<size_t, long> { size_t operator()(long __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<long long> : public __hash_base<size_t, long long> { size_t operator()(long long __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<unsigned short> : public __hash_base<size_t, unsigned short> { size_t operator()(unsigned short __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<unsigned int> : public __hash_base<size_t, unsigned int> { size_t operator()(unsigned int __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<unsigned long> : public __hash_base<size_t, unsigned long> { size_t operator()(unsigned long __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<unsigned long long> : public __hash_base<size_t, unsigned long long> { size_t operator()(unsigned long long __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
>
> struct _Hash_impl
> {
> static size_t
> hash(const void* __ptr, size_t __clength,
> size_t __seed = static_cast<size_t>(0xc70f6907UL))
> { return _Hash_bytes(__ptr, __clength, __seed); }
>
> template<typename _Tp>
> static size_t
> hash(const _Tp& __val)
> { return hash(&__val, sizeof(__val)); }
>
> template<typename _Tp>
> static size_t
> __hash_combine(const _Tp& __val, size_t __hash)
> { return hash(&__val, sizeof(__val), __hash); }
> };
>
> struct _Fnv_hash_impl
> {
> static size_t
> hash(const void* __ptr, size_t __clength,
> size_t __seed = static_cast<size_t>(2166136261UL))
> { return _Fnv_hash_bytes(__ptr, __clength, __seed); }
>
> template<typename _Tp>
> static size_t
> hash(const _Tp& __val)
> { return hash(&__val, sizeof(__val)); }
>
> template<typename _Tp>
> static size_t
> __hash_combine(const _Tp& __val, size_t __hash)
> { return hash(&__val, sizeof(__val), __hash); }
> };
>
>
> template<>
> struct hash<float> : public __hash_base<size_t, float>
> {
> size_t
> operator()(float __val) const noexcept
> {
>
> return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;
> }
> };
>
>
> template<>
> struct hash<double> : public __hash_base<size_t, double>
> {
> size_t
> operator()(double __val) const noexcept
> {
>
> return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;
> }
> };
>
>
> template<>
> struct hash<long double>
> : public __hash_base<size_t, long double>
> {
> __attribute__ ((__pure__)) size_t
> operator()(long double __val) const noexcept;
> };
>
>
>
>
>
>
>
> template<typename _Hash>
> struct __is_fast_hash : public std::true_type
> { };
>
> template<>
> struct __is_fast_hash<hash<long double>> : public std::false_type
> { };
>
>
>}
># 3034 "/usr/include/c++/4.8.2/bits/basic_string.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
> template<>
> struct hash<string>
> : public __hash_base<size_t, string>
> {
> size_t
> operator()(const string& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(), __s.length()); }
> };
>
> template<>
> struct __is_fast_hash<hash<string>> : std::false_type
> { };
>
>
>
> template<>
> struct hash<wstring>
> : public __hash_base<size_t, wstring>
> {
> size_t
> operator()(const wstring& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(),
> __s.length() * sizeof(wchar_t)); }
> };
>
> template<>
> struct __is_fast_hash<hash<wstring>> : std::false_type
> { };
>
>
>
>
>
> template<>
> struct hash<u16string>
> : public __hash_base<size_t, u16string>
> {
> size_t
> operator()(const u16string& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(),
> __s.length() * sizeof(char16_t)); }
> };
>
> template<>
> struct __is_fast_hash<hash<u16string>> : std::false_type
> { };
>
>
> template<>
> struct hash<u32string>
> : public __hash_base<size_t, u32string>
> {
> size_t
> operator()(const u32string& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(),
> __s.length() * sizeof(char32_t)); }
> };
>
> template<>
> struct __is_fast_hash<hash<u32string>> : std::false_type
> { };
>
>
>
>}
># 53 "/usr/include/c++/4.8.2/string" 2 3
># 1 "/usr/include/c++/4.8.2/bits/basic_string.tcc" 1 3
># 40 "/usr/include/c++/4.8.2/bits/basic_string.tcc" 3
> 
># 41 "/usr/include/c++/4.8.2/bits/basic_string.tcc" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> const typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> _Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> const _CharT
> basic_string<_CharT, _Traits, _Alloc>::
> _Rep::_S_terminal = _CharT();
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> const typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::npos;
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
> (sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
> sizeof(size_type)];
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> template<typename _InIterator>
> _CharT*
> basic_string<_CharT, _Traits, _Alloc>::
> _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
> input_iterator_tag)
> {
>
> if (__beg == __end && __a == _Alloc())
> return _S_empty_rep()._M_refdata();
>
>
> _CharT __buf[128];
> size_type __len = 0;
> while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
> {
> __buf[__len++] = *__beg;
> ++__beg;
> }
> _Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
> _M_copy(__r->_M_refdata(), __buf, __len);
> try
> {
> while (__beg != __end)
> {
> if (__len == __r->_M_capacity)
> {
>
> _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
> _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
> __r->_M_destroy(__a);
> __r = __another;
> }
> __r->_M_refdata()[__len++] = *__beg;
> ++__beg;
> }
> }
> catch(...)
> {
> __r->_M_destroy(__a);
> throw;
> }
> __r->_M_set_length_and_sharable(__len);
> return __r->_M_refdata();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> template <typename _InIterator>
> _CharT*
> basic_string<_CharT, _Traits, _Alloc>::
> _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
> forward_iterator_tag)
> {
>
> if (__beg == __end && __a == _Alloc())
> return _S_empty_rep()._M_refdata();
>
>
> if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
> __throw_logic_error(("basic_string::_S_construct null not valid"));
>
> const size_type __dnew = static_cast<size_type>(std::distance(__beg,
> __end));
>
> _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
> try
> { _S_copy_chars(__r->_M_refdata(), __beg, __end); }
> catch(...)
> {
> __r->_M_destroy(__a);
> throw;
> }
> __r->_M_set_length_and_sharable(__dnew);
> return __r->_M_refdata();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> _CharT*
> basic_string<_CharT, _Traits, _Alloc>::
> _S_construct(size_type __n, _CharT __c, const _Alloc& __a)
> {
>
> if (__n == 0 && __a == _Alloc())
> return _S_empty_rep()._M_refdata();
>
>
> _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
> if (__n)
> _M_assign(__r->_M_refdata(), __n, __c);
>
> __r->_M_set_length_and_sharable(__n);
> return __r->_M_refdata();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const basic_string& __str)
> : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
> __str.get_allocator()),
> __str.get_allocator())
> { }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const _Alloc& __a)
> : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
> { }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const basic_string& __str, size_type __pos, size_type __n)
> : _M_dataplus(_S_construct(__str._M_data()
> + __str._M_check(__pos,
> "basic_string::basic_string"),
> __str._M_data() + __str._M_limit(__pos, __n)
> + __pos, _Alloc()), _Alloc())
> { }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const basic_string& __str, size_type __pos,
> size_type __n, const _Alloc& __a)
> : _M_dataplus(_S_construct(__str._M_data()
> + __str._M_check(__pos,
> "basic_string::basic_string"),
> __str._M_data() + __str._M_limit(__pos, __n)
> + __pos, __a), __a)
> { }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
> : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
> { }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const _CharT* __s, const _Alloc& __a)
> : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
> __s + npos, __a), __a)
> { }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(size_type __n, _CharT __c, const _Alloc& __a)
> : _M_dataplus(_S_construct(__n, __c, __a), __a)
> { }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> template<typename _InputIterator>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a)
> : _M_dataplus(_S_construct(__beg, __end, __a), __a)
> { }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(initializer_list<_CharT> __l, const _Alloc& __a)
> : _M_dataplus(_S_construct(__l.begin(), __l.end(), __a), __a)
> { }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> assign(const basic_string& __str)
> {
> if (_M_rep() != __str._M_rep())
> {
>
> const allocator_type __a = this->get_allocator();
> _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
> _M_rep()->_M_dispose(__a);
> _M_data(__tmp);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> assign(const _CharT* __s, size_type __n)
> {
> ;
> _M_check_length(this->size(), __n, "basic_string::assign");
> if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
> return _M_replace_safe(size_type(0), this->size(), __s, __n);
> else
> {
>
> const size_type __pos = __s - _M_data();
> if (__pos >= __n)
> _M_copy(_M_data(), __s, __n);
> else if (__pos)
> _M_move(_M_data(), __s, __n);
> _M_rep()->_M_set_length_and_sharable(__n);
> return *this;
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> append(size_type __n, _CharT __c)
> {
> if (__n)
> {
> _M_check_length(size_type(0), __n, "basic_string::append");
> const size_type __len = __n + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
> this->reserve(__len);
> _M_assign(_M_data() + this->size(), __n, __c);
> _M_rep()->_M_set_length_and_sharable(__len);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> append(const _CharT* __s, size_type __n)
> {
> ;
> if (__n)
> {
> _M_check_length(size_type(0), __n, "basic_string::append");
> const size_type __len = __n + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
> {
> if (_M_disjunct(__s))
> this->reserve(__len);
> else
> {
> const size_type __off = __s - _M_data();
> this->reserve(__len);
> __s = _M_data() + __off;
> }
> }
> _M_copy(_M_data() + this->size(), __s, __n);
> _M_rep()->_M_set_length_and_sharable(__len);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> append(const basic_string& __str)
> {
> const size_type __size = __str.size();
> if (__size)
> {
> const size_type __len = __size + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
> this->reserve(__len);
> _M_copy(_M_data() + this->size(), __str._M_data(), __size);
> _M_rep()->_M_set_length_and_sharable(__len);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> append(const basic_string& __str, size_type __pos, size_type __n)
> {
> __str._M_check(__pos, "basic_string::append");
> __n = __str._M_limit(__pos, __n);
> if (__n)
> {
> const size_type __len = __n + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
> this->reserve(__len);
> _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
> _M_rep()->_M_set_length_and_sharable(__len);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> insert(size_type __pos, const _CharT* __s, size_type __n)
> {
> ;
> _M_check(__pos, "basic_string::insert");
> _M_check_length(size_type(0), __n, "basic_string::insert");
> if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
> return _M_replace_safe(__pos, size_type(0), __s, __n);
> else
> {
>
> const size_type __off = __s - _M_data();
> _M_mutate(__pos, 0, __n);
> __s = _M_data() + __off;
> _CharT* __p = _M_data() + __pos;
> if (__s + __n <= __p)
> _M_copy(__p, __s, __n);
> else if (__s >= __p)
> _M_copy(__p, __s + __n, __n);
> else
> {
> const size_type __nleft = __p - __s;
> _M_copy(__p, __s, __nleft);
> _M_copy(__p + __nleft, __p + __n, __n - __nleft);
> }
> return *this;
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::iterator
> basic_string<_CharT, _Traits, _Alloc>::
> erase(iterator __first, iterator __last)
> {
> 
> ;
>
>
>
>
> const size_type __size = __last - __first;
> if (__size)
> {
> const size_type __pos = __first - _M_ibegin();
> _M_mutate(__pos, __size, size_type(0));
> _M_rep()->_M_set_leaked();
> return iterator(_M_data() + __pos);
> }
> else
> return __first;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> replace(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2)
> {
> ;
> _M_check(__pos, "basic_string::replace");
> __n1 = _M_limit(__pos, __n1);
> _M_check_length(__n1, __n2, "basic_string::replace");
> bool __left;
> if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
> return _M_replace_safe(__pos, __n1, __s, __n2);
> else if ((__left = __s + __n2 <= _M_data() + __pos)
> || _M_data() + __pos + __n1 <= __s)
> {
>
> size_type __off = __s - _M_data();
> __left ? __off : (__off += __n2 - __n1);
> _M_mutate(__pos, __n1, __n2);
> _M_copy(_M_data() + __pos, _M_data() + __off, __n2);
> return *this;
> }
> else
> {
>
> const basic_string __tmp(__s, __n2);
> return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::_Rep::
> _M_destroy(const _Alloc& __a) throw ()
> {
> const size_type __size = sizeof(_Rep_base) +
> (this->_M_capacity + 1) * sizeof(_CharT);
> _Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> _M_leak_hard()
> {
>
> if (_M_rep() == &_S_empty_rep())
> return;
>
> if (_M_rep()->_M_is_shared())
> _M_mutate(0, 0, 0);
> _M_rep()->_M_set_leaked();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> _M_mutate(size_type __pos, size_type __len1, size_type __len2)
> {
> const size_type __old_size = this->size();
> const size_type __new_size = __old_size + __len2 - __len1;
> const size_type __how_much = __old_size - __pos - __len1;
>
> if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
> {
>
> const allocator_type __a = get_allocator();
> _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
>
> if (__pos)
> _M_copy(__r->_M_refdata(), _M_data(), __pos);
> if (__how_much)
> _M_copy(__r->_M_refdata() + __pos + __len2,
> _M_data() + __pos + __len1, __how_much);
>
> _M_rep()->_M_dispose(__a);
> _M_data(__r->_M_refdata());
> }
> else if (__how_much && __len1 != __len2)
> {
>
> _M_move(_M_data() + __pos + __len2,
> _M_data() + __pos + __len1, __how_much);
> }
> _M_rep()->_M_set_length_and_sharable(__new_size);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> reserve(size_type __res)
> {
> if (__res != this->capacity() || _M_rep()->_M_is_shared())
> {
>
> if (__res < this->size())
> __res = this->size();
> const allocator_type __a = get_allocator();
> _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
> _M_rep()->_M_dispose(__a);
> _M_data(__tmp);
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> swap(basic_string& __s)
> {
> if (_M_rep()->_M_is_leaked())
> _M_rep()->_M_set_sharable();
> if (__s._M_rep()->_M_is_leaked())
> __s._M_rep()->_M_set_sharable();
> if (this->get_allocator() == __s.get_allocator())
> {
> _CharT* __tmp = _M_data();
> _M_data(__s._M_data());
> __s._M_data(__tmp);
> }
>
> else
> {
> const basic_string __tmp1(_M_ibegin(), _M_iend(),
> __s.get_allocator());
> const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
> this->get_allocator());
> *this = __tmp2;
> __s = __tmp1;
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
> basic_string<_CharT, _Traits, _Alloc>::_Rep::
> _S_create(size_type __capacity, size_type __old_capacity,
> const _Alloc& __alloc)
> {
>
>
> if (__capacity > _S_max_size)
> __throw_length_error(("basic_string::_S_create"));
># 577 "/usr/include/c++/4.8.2/bits/basic_string.tcc" 3
> const size_type __pagesize = 4096;
> const size_type __malloc_header_size = 4 * sizeof(void*);
>
>
>
>
>
>
>
> if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
> __capacity = 2 * __old_capacity;
>
>
>
>
> size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
>
> const size_type __adj_size = __size + __malloc_header_size;
> if (__adj_size > __pagesize && __capacity > __old_capacity)
> {
> const size_type __extra = __pagesize - __adj_size % __pagesize;
> __capacity += __extra / sizeof(_CharT);
>
> if (__capacity > _S_max_size)
> __capacity = _S_max_size;
> __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
> }
>
>
>
> void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
> _Rep *__p = new (__place) _Rep;
> __p->_M_capacity = __capacity;
>
>
>
>
>
>
>
> __p->_M_set_sharable();
> return __p;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> _CharT*
> basic_string<_CharT, _Traits, _Alloc>::_Rep::
> _M_clone(const _Alloc& __alloc, size_type __res)
> {
>
> const size_type __requested_cap = this->_M_length + __res;
> _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
> __alloc);
> if (this->_M_length)
> _M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
>
> __r->_M_set_length_and_sharable(this->_M_length);
> return __r->_M_refdata();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> resize(size_type __n, _CharT __c)
> {
> const size_type __size = this->size();
> _M_check_length(__size, __n, "basic_string::resize");
> if (__size < __n)
> this->append(__n - __size, __c);
> else if (__n < __size)
> this->erase(__n);
>
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> template<typename _InputIterator>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
> _InputIterator __k2, __false_type)
> {
> const basic_string __s(__k1, __k2);
> const size_type __n1 = __i2 - __i1;
> _M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
> return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
> __s.size());
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
> _CharT __c)
> {
> _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
> _M_mutate(__pos1, __n1, __n2);
> if (__n2)
> _M_assign(_M_data() + __pos1, __n2, __c);
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
> size_type __n2)
> {
> _M_mutate(__pos1, __n1, __n2);
> if (__n2)
> _M_copy(_M_data() + __pos1, __s, __n2);
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>
> operator+(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> {
> ;
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
> const __size_type __len = _Traits::length(__lhs);
> __string_type __str;
> __str.reserve(__len + __rhs.size());
> __str.append(__lhs, __len);
> __str.append(__rhs);
> return __str;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>
> operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> {
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
> __string_type __str;
> const __size_type __len = __rhs.size();
> __str.reserve(__len + 1);
> __str.append(__size_type(1), __lhs);
> __str.append(__rhs);
> return __str;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> copy(_CharT* __s, size_type __n, size_type __pos) const
> {
> _M_check(__pos, "basic_string::copy");
> __n = _M_limit(__pos, __n);
> ;
> if (__n)
> _M_copy(__s, _M_data() + __pos, __n);
>
> return __n;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> const size_type __size = this->size();
> const _CharT* __data = _M_data();
>
> if (__n == 0)
> return __pos <= __size ? __pos : npos;
>
> if (__n <= __size)
> {
> for (; __pos <= __size - __n; ++__pos)
> if (traits_type::eq(__data[__pos], __s[0])
> && traits_type::compare(__data + __pos + 1,
> __s + 1, __n - 1) == 0)
> return __pos;
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find(_CharT __c, size_type __pos) const noexcept
> {
> size_type __ret = npos;
> const size_type __size = this->size();
> if (__pos < __size)
> {
> const _CharT* __data = _M_data();
> const size_type __n = __size - __pos;
> const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
> if (__p)
> __ret = __p - __data;
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> rfind(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> const size_type __size = this->size();
> if (__n <= __size)
> {
> __pos = std::min(size_type(__size - __n), __pos);
> const _CharT* __data = _M_data();
> do
> {
> if (traits_type::compare(__data + __pos, __s, __n) == 0)
> return __pos;
> }
> while (__pos-- > 0);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> rfind(_CharT __c, size_type __pos) const noexcept
> {
> size_type __size = this->size();
> if (__size)
> {
> if (--__size > __pos)
> __size = __pos;
> for (++__size; __size-- > 0; )
> if (traits_type::eq(_M_data()[__size], __c))
> return __size;
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> for (; __n && __pos < this->size(); ++__pos)
> {
> const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
> if (__p)
> return __pos;
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> size_type __size = this->size();
> if (__size && __n)
> {
> if (--__size > __pos)
> __size = __pos;
> do
> {
> if (traits_type::find(__s, __n, _M_data()[__size]))
> return __size;
> }
> while (__size-- != 0);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> for (; __pos < this->size(); ++__pos)
> if (!traits_type::find(__s, __n, _M_data()[__pos]))
> return __pos;
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_first_not_of(_CharT __c, size_type __pos) const noexcept
> {
> for (; __pos < this->size(); ++__pos)
> if (!traits_type::eq(_M_data()[__pos], __c))
> return __pos;
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> size_type __size = this->size();
> if (__size)
> {
> if (--__size > __pos)
> __size = __pos;
> do
> {
> if (!traits_type::find(__s, __n, _M_data()[__size]))
> return __size;
> }
> while (__size--);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_last_not_of(_CharT __c, size_type __pos) const noexcept
> {
> size_type __size = this->size();
> if (__size)
> {
> if (--__size > __pos)
> __size = __pos;
> do
> {
> if (!traits_type::eq(_M_data()[__size], __c))
> return __size;
> }
> while (__size--);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string<_CharT, _Traits, _Alloc>::
> compare(size_type __pos, size_type __n, const basic_string& __str) const
> {
> _M_check(__pos, "basic_string::compare");
> __n = _M_limit(__pos, __n);
> const size_type __osize = __str.size();
> const size_type __len = std::min(__n, __osize);
> int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
> if (!__r)
> __r = _S_compare(__n, __osize);
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string<_CharT, _Traits, _Alloc>::
> compare(size_type __pos1, size_type __n1, const basic_string& __str,
> size_type __pos2, size_type __n2) const
> {
> _M_check(__pos1, "basic_string::compare");
> __str._M_check(__pos2, "basic_string::compare");
> __n1 = _M_limit(__pos1, __n1);
> __n2 = __str._M_limit(__pos2, __n2);
> const size_type __len = std::min(__n1, __n2);
> int __r = traits_type::compare(_M_data() + __pos1,
> __str.data() + __pos2, __len);
> if (!__r)
> __r = _S_compare(__n1, __n2);
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string<_CharT, _Traits, _Alloc>::
> compare(const _CharT* __s) const
> {
> ;
> const size_type __size = this->size();
> const size_type __osize = traits_type::length(__s);
> const size_type __len = std::min(__size, __osize);
> int __r = traits_type::compare(_M_data(), __s, __len);
> if (!__r)
> __r = _S_compare(__size, __osize);
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string <_CharT, _Traits, _Alloc>::
> compare(size_type __pos, size_type __n1, const _CharT* __s) const
> {
> ;
> _M_check(__pos, "basic_string::compare");
> __n1 = _M_limit(__pos, __n1);
> const size_type __osize = traits_type::length(__s);
> const size_type __len = std::min(__n1, __osize);
> int __r = traits_type::compare(_M_data() + __pos, __s, __len);
> if (!__r)
> __r = _S_compare(__n1, __osize);
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string <_CharT, _Traits, _Alloc>::
> compare(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2) const
> {
> ;
> _M_check(__pos, "basic_string::compare");
> __n1 = _M_limit(__pos, __n1);
> const size_type __len = std::min(__n1, __n2);
> int __r = traits_type::compare(_M_data() + __pos, __s, __len);
> if (!__r)
> __r = _S_compare(__n1, __n2);
> return __r;
> }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in,
> basic_string<_CharT, _Traits, _Alloc>& __str)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __istream_type::ios_base __ios_base;
> typedef typename __istream_type::int_type __int_type;
> typedef typename __string_type::size_type __size_type;
> typedef ctype<_CharT> __ctype_type;
> typedef typename __ctype_type::ctype_base __ctype_base;
>
> __size_type __extracted = 0;
> typename __ios_base::iostate __err = __ios_base::goodbit;
> typename __istream_type::sentry __cerb(__in, false);
> if (__cerb)
> {
> try
> {
>
> __str.erase();
> _CharT __buf[128];
> __size_type __len = 0;
> const streamsize __w = __in.width();
> const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
> : __str.max_size();
> const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
> const __int_type __eof = _Traits::eof();
> __int_type __c = __in.rdbuf()->sgetc();
>
> while (__extracted < __n
> && !_Traits::eq_int_type(__c, __eof)
> && !__ct.is(__ctype_base::space,
> _Traits::to_char_type(__c)))
> {
> if (__len == sizeof(__buf) / sizeof(_CharT))
> {
> __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
> __len = 0;
> }
> __buf[__len++] = _Traits::to_char_type(__c);
> ++__extracted;
> __c = __in.rdbuf()->snextc();
> }
> __str.append(__buf, __len);
>
> if (_Traits::eq_int_type(__c, __eof))
> __err |= __ios_base::eofbit;
> __in.width(0);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __in._M_setstate(__ios_base::badbit);
> throw;
> }
> catch(...)
> {
>
>
>
> __in._M_setstate(__ios_base::badbit);
> }
> }
>
> if (!__extracted)
> __err |= __ios_base::failbit;
> if (__err)
> __in.setstate(__err);
> return __in;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_istream<_CharT, _Traits>&
> getline(basic_istream<_CharT, _Traits>& __in,
> basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __istream_type::ios_base __ios_base;
> typedef typename __istream_type::int_type __int_type;
> typedef typename __string_type::size_type __size_type;
>
> __size_type __extracted = 0;
> const __size_type __n = __str.max_size();
> typename __ios_base::iostate __err = __ios_base::goodbit;
> typename __istream_type::sentry __cerb(__in, true);
> if (__cerb)
> {
> try
> {
> __str.erase();
> const __int_type __idelim = _Traits::to_int_type(__delim);
> const __int_type __eof = _Traits::eof();
> __int_type __c = __in.rdbuf()->sgetc();
>
> while (__extracted < __n
> && !_Traits::eq_int_type(__c, __eof)
> && !_Traits::eq_int_type(__c, __idelim))
> {
> __str += _Traits::to_char_type(__c);
> ++__extracted;
> __c = __in.rdbuf()->snextc();
> }
>
> if (_Traits::eq_int_type(__c, __eof))
> __err |= __ios_base::eofbit;
> else if (_Traits::eq_int_type(__c, __idelim))
> {
> ++__extracted;
> __in.rdbuf()->sbumpc();
> }
> else
> __err |= __ios_base::failbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __in._M_setstate(__ios_base::badbit);
> throw;
> }
> catch(...)
> {
>
>
>
> __in._M_setstate(__ios_base::badbit);
> }
> }
> if (!__extracted)
> __err |= __ios_base::failbit;
> if (__err)
> __in.setstate(__err);
> return __in;
> }
>
>
>
>
> extern template class basic_string<char>;
> extern template
> basic_istream<char>&
> operator>>(basic_istream<char>&, string&);
> extern template
> basic_ostream<char>&
> operator<<(basic_ostream<char>&, const string&);
> extern template
> basic_istream<char>&
> getline(basic_istream<char>&, string&, char);
> extern template
> basic_istream<char>&
> getline(basic_istream<char>&, string&);
>
>
> extern template class basic_string<wchar_t>;
> extern template
> basic_istream<wchar_t>&
> operator>>(basic_istream<wchar_t>&, wstring&);
> extern template
> basic_ostream<wchar_t>&
> operator<<(basic_ostream<wchar_t>&, const wstring&);
> extern template
> basic_istream<wchar_t>&
> getline(basic_istream<wchar_t>&, wstring&, wchar_t);
> extern template
> basic_istream<wchar_t>&
> getline(basic_istream<wchar_t>&, wstring&);
>
>
>
>
>}
># 54 "/usr/include/c++/4.8.2/string" 2 3
># 41 "/usr/include/c++/4.8.2/bits/locale_classes.h" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 62 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> class locale
> {
> public:
>
>
> typedef int category;
>
>
> class facet;
> class id;
> class _Impl;
>
> friend class facet;
> friend class _Impl;
>
> template<typename _Facet>
> friend bool
> has_facet(const locale&) throw();
>
> template<typename _Facet>
> friend const _Facet&
> use_facet(const locale&);
>
> template<typename _Cache>
> friend struct __use_cache;
># 98 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> static const category none = 0;
> static const category ctype = 1L << 0;
> static const category numeric = 1L << 1;
> static const category collate = 1L << 2;
> static const category time = 1L << 3;
> static const category monetary = 1L << 4;
> static const category messages = 1L << 5;
> static const category all = (ctype | numeric | collate |
> time | monetary | messages);
># 117 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> locale() throw();
># 126 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> locale(const locale& __other) throw();
># 136 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> explicit
> locale(const char* __s);
># 151 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> locale(const locale& __base, const char* __s, category __cat);
># 164 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> locale(const locale& __base, const locale& __add, category __cat);
># 177 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> template<typename _Facet>
> locale(const locale& __other, _Facet* __f);
>
>
> ~locale() throw();
># 191 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> const locale&
> operator=(const locale& __other) throw();
># 206 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> template<typename _Facet>
> locale
> combine(const locale& __other) const;
>
>
>
>
>
>
> string
> name() const;
># 225 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> bool
> operator==(const locale& __other) const throw();
>
>
>
>
>
>
>
> bool
> operator!=(const locale& __other) const throw()
> { return !(this->operator==(__other)); }
># 253 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> template<typename _Char, typename _Traits, typename _Alloc>
> bool
> operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
> const basic_string<_Char, _Traits, _Alloc>& __s2) const;
># 269 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> static locale
> global(const locale& __loc);
>
>
>
>
> static const locale&
> classic();
>
> private:
>
> _Impl* _M_impl;
>
>
> static _Impl* _S_classic;
>
>
> static _Impl* _S_global;
>
>
>
>
>
> static const char* const* const _S_categories;
># 304 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> enum { _S_categories_size = 6 + 6 };
>
>
> static __gthread_once_t _S_once;
>
>
> explicit
> locale(_Impl*) throw();
>
> static void
> _S_initialize();
>
> static void
> _S_initialize_once() throw();
>
> static category
> _S_normalize_category(category);
>
> void
> _M_coalesce(const locale& __base, const locale& __add, category __cat);
> };
># 338 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> class locale::facet
> {
> private:
> friend class locale;
> friend class locale::_Impl;
>
> mutable _Atomic_word _M_refcount;
>
>
> static __c_locale _S_c_locale;
>
>
> static const char _S_c_name[2];
>
>
> static __gthread_once_t _S_once;
>
>
> static void
> _S_initialize_once();
>
> protected:
># 369 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> explicit
> facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
> { }
>
>
> virtual
> ~facet();
>
> static void
> _S_create_c_locale(__c_locale& __cloc, const char* __s,
> __c_locale __old = 0);
>
> static __c_locale
> _S_clone_c_locale(__c_locale& __cloc) throw();
>
> static void
> _S_destroy_c_locale(__c_locale& __cloc);
>
> static __c_locale
> _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
>
>
>
> static __c_locale
> _S_get_c_locale();
>
> __attribute__ ((__const__)) static const char*
> _S_get_c_name() throw();
>
> private:
> void
> _M_add_reference() const throw()
> { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
>
> void
> _M_remove_reference() const throw()
> {
>
> ;
> if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
> {
> ;
> try
> { delete this; }
> catch(...)
> { }
> }
> }
>
> facet(const facet&);
>
> facet&
> operator=(const facet&);
> };
># 436 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> class locale::id
> {
> private:
> friend class locale;
> friend class locale::_Impl;
>
> template<typename _Facet>
> friend const _Facet&
> use_facet(const locale&);
>
> template<typename _Facet>
> friend bool
> has_facet(const locale&) throw();
>
>
>
>
> mutable size_t _M_index;
>
>
> static _Atomic_word _S_refcount;
>
> void
> operator=(const id&);
>
> id(const id&);
>
> public:
>
>
>
> id() { }
>
> size_t
> _M_id() const throw();
> };
>
>
>
> class locale::_Impl
> {
> public:
>
> friend class locale;
> friend class locale::facet;
>
> template<typename _Facet>
> friend bool
> has_facet(const locale&) throw();
>
> template<typename _Facet>
> friend const _Facet&
> use_facet(const locale&);
>
> template<typename _Cache>
> friend struct __use_cache;
>
> private:
>
> _Atomic_word _M_refcount;
> const facet** _M_facets;
> size_t _M_facets_size;
> const facet** _M_caches;
> char** _M_names;
> static const locale::id* const _S_id_ctype[];
> static const locale::id* const _S_id_numeric[];
> static const locale::id* const _S_id_collate[];
> static const locale::id* const _S_id_time[];
> static const locale::id* const _S_id_monetary[];
> static const locale::id* const _S_id_messages[];
> static const locale::id* const* const _S_facet_categories[];
>
> void
> _M_add_reference() throw()
> { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
>
> void
> _M_remove_reference() throw()
> {
>
> ;
> if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
> {
> ;
> try
> { delete this; }
> catch(...)
> { }
> }
> }
>
> _Impl(const _Impl&, size_t);
> _Impl(const char*, size_t);
> _Impl(size_t) throw();
>
> ~_Impl() throw();
>
> _Impl(const _Impl&);
>
> void
> operator=(const _Impl&);
>
> bool
> _M_check_same_name()
> {
> bool __ret = true;
> if (_M_names[1])
>
> for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
> __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
> return __ret;
> }
>
> void
> _M_replace_categories(const _Impl*, category);
>
> void
> _M_replace_category(const _Impl*, const locale::id* const*);
>
> void
> _M_replace_facet(const _Impl*, const locale::id*);
>
> void
> _M_install_facet(const locale::id*, const facet*);
>
> template<typename _Facet>
> void
> _M_init_facet(_Facet* __facet)
> { _M_install_facet(&_Facet::id, __facet); }
>
> void
> _M_install_cache(const facet*, size_t);
> };
># 583 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> template<typename _CharT>
> class collate : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
>
> protected:
>
>
> __c_locale _M_c_locale_collate;
>
> public:
>
> static locale::id id;
># 610 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> explicit
> collate(size_t __refs = 0)
> : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
> { }
># 624 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> explicit
> collate(__c_locale __cloc, size_t __refs = 0)
> : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
> { }
># 641 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> int
> compare(const _CharT* __lo1, const _CharT* __hi1,
> const _CharT* __lo2, const _CharT* __hi2) const
> { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
># 660 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> string_type
> transform(const _CharT* __lo, const _CharT* __hi) const
> { return this->do_transform(__lo, __hi); }
># 674 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> long
> hash(const _CharT* __lo, const _CharT* __hi) const
> { return this->do_hash(__lo, __hi); }
>
>
> int
> _M_compare(const _CharT*, const _CharT*) const throw();
>
> size_t
> _M_transform(_CharT*, const _CharT*, size_t) const throw();
>
> protected:
>
> virtual
> ~collate()
> { _S_destroy_c_locale(_M_c_locale_collate); }
># 703 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> virtual int
> do_compare(const _CharT* __lo1, const _CharT* __hi1,
> const _CharT* __lo2, const _CharT* __hi2) const;
># 717 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> virtual string_type
> do_transform(const _CharT* __lo, const _CharT* __hi) const;
># 730 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
> virtual long
> do_hash(const _CharT* __lo, const _CharT* __hi) const;
> };
>
> template<typename _CharT>
> locale::id collate<_CharT>::id;
>
>
> template<>
> int
> collate<char>::_M_compare(const char*, const char*) const throw();
>
> template<>
> size_t
> collate<char>::_M_transform(char*, const char*, size_t) const throw();
>
>
> template<>
> int
> collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
>
> template<>
> size_t
> collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
>
>
>
> template<typename _CharT>
> class collate_byname : public collate<_CharT>
> {
> public:
>
>
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
>
> explicit
> collate_byname(const char* __s, size_t __refs = 0)
> : collate<_CharT>(__refs)
> {
> if (__builtin_strcmp(__s, "C") != 0
> && __builtin_strcmp(__s, "POSIX") != 0)
> {
> this->_S_destroy_c_locale(this->_M_c_locale_collate);
> this->_S_create_c_locale(this->_M_c_locale_collate, __s);
> }
> }
>
> protected:
> virtual
> ~collate_byname() { }
> };
>
>
>}
>
># 1 "/usr/include/c++/4.8.2/bits/locale_classes.tcc" 1 3
># 37 "/usr/include/c++/4.8.2/bits/locale_classes.tcc" 3
> 
># 38 "/usr/include/c++/4.8.2/bits/locale_classes.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Facet>
> locale::
> locale(const locale& __other, _Facet* __f)
> {
> _M_impl = new _Impl(*__other._M_impl, 1);
>
> try
> { _M_impl->_M_install_facet(&_Facet::id, __f); }
> catch(...)
> {
> _M_impl->_M_remove_reference();
> throw;
> }
> delete [] _M_impl->_M_names[0];
> _M_impl->_M_names[0] = 0;
> }
>
> template<typename _Facet>
> locale
> locale::
> combine(const locale& __other) const
> {
> _Impl* __tmp = new _Impl(*_M_impl, 1);
> try
> {
> __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
> }
> catch(...)
> {
> __tmp->_M_remove_reference();
> throw;
> }
> return locale(__tmp);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> bool
> locale::
> operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
> const basic_string<_CharT, _Traits, _Alloc>& __s2) const
> {
> typedef std::collate<_CharT> __collate_type;
> const __collate_type& __collate = use_facet<__collate_type>(*this);
> return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
> __s2.data(), __s2.data() + __s2.length()) < 0);
> }
># 102 "/usr/include/c++/4.8.2/bits/locale_classes.tcc" 3
> template<typename _Facet>
> bool
> has_facet(const locale& __loc) throw()
> {
> const size_t __i = _Facet::id._M_id();
> const locale::facet** __facets = __loc._M_impl->_M_facets;
> return (__i < __loc._M_impl->_M_facets_size
>
> && dynamic_cast<const _Facet*>(__facets[__i]));
>
>
>
> }
># 130 "/usr/include/c++/4.8.2/bits/locale_classes.tcc" 3
> template<typename _Facet>
> const _Facet&
> use_facet(const locale& __loc)
> {
> const size_t __i = _Facet::id._M_id();
> const locale::facet** __facets = __loc._M_impl->_M_facets;
> if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
> __throw_bad_cast();
>
> return dynamic_cast<const _Facet&>(*__facets[__i]);
>
>
>
> }
>
>
>
> template<typename _CharT>
> int
> collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
> { return 0; }
>
>
> template<typename _CharT>
> size_t
> collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
> { return 0; }
>
> template<typename _CharT>
> int
> collate<_CharT>::
> do_compare(const _CharT* __lo1, const _CharT* __hi1,
> const _CharT* __lo2, const _CharT* __hi2) const
> {
>
>
> const string_type __one(__lo1, __hi1);
> const string_type __two(__lo2, __hi2);
>
> const _CharT* __p = __one.c_str();
> const _CharT* __pend = __one.data() + __one.length();
> const _CharT* __q = __two.c_str();
> const _CharT* __qend = __two.data() + __two.length();
>
>
>
>
> for (;;)
> {
> const int __res = _M_compare(__p, __q);
> if (__res)
> return __res;
>
> __p += char_traits<_CharT>::length(__p);
> __q += char_traits<_CharT>::length(__q);
> if (__p == __pend && __q == __qend)
> return 0;
> else if (__p == __pend)
> return -1;
> else if (__q == __qend)
> return 1;
>
> __p++;
> __q++;
> }
> }
>
> template<typename _CharT>
> typename collate<_CharT>::string_type
> collate<_CharT>::
> do_transform(const _CharT* __lo, const _CharT* __hi) const
> {
> string_type __ret;
>
>
> const string_type __str(__lo, __hi);
>
> const _CharT* __p = __str.c_str();
> const _CharT* __pend = __str.data() + __str.length();
>
> size_t __len = (__hi - __lo) * 2;
>
> _CharT* __c = new _CharT[__len];
>
> try
> {
>
>
>
> for (;;)
> {
>
> size_t __res = _M_transform(__c, __p, __len);
>
>
> if (__res >= __len)
> {
> __len = __res + 1;
> delete [] __c, __c = 0;
> __c = new _CharT[__len];
> __res = _M_transform(__c, __p, __len);
> }
>
> __ret.append(__c, __res);
> __p += char_traits<_CharT>::length(__p);
> if (__p == __pend)
> break;
>
> __p++;
> __ret.push_back(_CharT());
> }
> }
> catch(...)
> {
> delete [] __c;
> throw;
> }
>
> delete [] __c;
>
> return __ret;
> }
>
> template<typename _CharT>
> long
> collate<_CharT>::
> do_hash(const _CharT* __lo, const _CharT* __hi) const
> {
> unsigned long __val = 0;
> for (; __lo < __hi; ++__lo)
> __val =
> *__lo + ((__val << 7)
> | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
> __digits - 7)));
> return static_cast<long>(__val);
> }
>
>
>
>
> extern template class collate<char>;
> extern template class collate_byname<char>;
>
> extern template
> const collate<char>&
> use_facet<collate<char> >(const locale&);
>
> extern template
> bool
> has_facet<collate<char> >(const locale&);
>
>
> extern template class collate<wchar_t>;
> extern template class collate_byname<wchar_t>;
>
> extern template
> const collate<wchar_t>&
> use_facet<collate<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<collate<wchar_t> >(const locale&);
>
>
>
>
>}
># 788 "/usr/include/c++/4.8.2/bits/locale_classes.h" 2 3
># 42 "/usr/include/c++/4.8.2/bits/ios_base.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
> enum _Ios_Fmtflags
> {
> _S_boolalpha = 1L << 0,
> _S_dec = 1L << 1,
> _S_fixed = 1L << 2,
> _S_hex = 1L << 3,
> _S_internal = 1L << 4,
> _S_left = 1L << 5,
> _S_oct = 1L << 6,
> _S_right = 1L << 7,
> _S_scientific = 1L << 8,
> _S_showbase = 1L << 9,
> _S_showpoint = 1L << 10,
> _S_showpos = 1L << 11,
> _S_skipws = 1L << 12,
> _S_unitbuf = 1L << 13,
> _S_uppercase = 1L << 14,
> _S_adjustfield = _S_left | _S_right | _S_internal,
> _S_basefield = _S_dec | _S_oct | _S_hex,
> _S_floatfield = _S_scientific | _S_fixed,
> _S_ios_fmtflags_end = 1L << 16
> };
>
> inline constexpr _Ios_Fmtflags
> operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
> { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
>
> inline constexpr _Ios_Fmtflags
> operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
> { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
>
> inline constexpr _Ios_Fmtflags
> operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
> { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
>
> inline constexpr _Ios_Fmtflags
> operator~(_Ios_Fmtflags __a)
> { return _Ios_Fmtflags(~static_cast<int>(__a)); }
>
> inline const _Ios_Fmtflags&
> operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
> { return __a = __a | __b; }
>
> inline const _Ios_Fmtflags&
> operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
> { return __a = __a & __b; }
>
> inline const _Ios_Fmtflags&
> operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
> { return __a = __a ^ __b; }
>
>
> enum _Ios_Openmode
> {
> _S_app = 1L << 0,
> _S_ate = 1L << 1,
> _S_bin = 1L << 2,
> _S_in = 1L << 3,
> _S_out = 1L << 4,
> _S_trunc = 1L << 5,
> _S_ios_openmode_end = 1L << 16
> };
>
> inline constexpr _Ios_Openmode
> operator&(_Ios_Openmode __a, _Ios_Openmode __b)
> { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
>
> inline constexpr _Ios_Openmode
> operator|(_Ios_Openmode __a, _Ios_Openmode __b)
> { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
>
> inline constexpr _Ios_Openmode
> operator^(_Ios_Openmode __a, _Ios_Openmode __b)
> { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
>
> inline constexpr _Ios_Openmode
> operator~(_Ios_Openmode __a)
> { return _Ios_Openmode(~static_cast<int>(__a)); }
>
> inline const _Ios_Openmode&
> operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
> { return __a = __a | __b; }
>
> inline const _Ios_Openmode&
> operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
> { return __a = __a & __b; }
>
> inline const _Ios_Openmode&
> operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
> { return __a = __a ^ __b; }
>
>
> enum _Ios_Iostate
> {
> _S_goodbit = 0,
> _S_badbit = 1L << 0,
> _S_eofbit = 1L << 1,
> _S_failbit = 1L << 2,
> _S_ios_iostate_end = 1L << 16
> };
>
> inline constexpr _Ios_Iostate
> operator&(_Ios_Iostate __a, _Ios_Iostate __b)
> { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
>
> inline constexpr _Ios_Iostate
> operator|(_Ios_Iostate __a, _Ios_Iostate __b)
> { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
>
> inline constexpr _Ios_Iostate
> operator^(_Ios_Iostate __a, _Ios_Iostate __b)
> { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
>
> inline constexpr _Ios_Iostate
> operator~(_Ios_Iostate __a)
> { return _Ios_Iostate(~static_cast<int>(__a)); }
>
> inline const _Ios_Iostate&
> operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
> { return __a = __a | __b; }
>
> inline const _Ios_Iostate&
> operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
> { return __a = __a & __b; }
>
> inline const _Ios_Iostate&
> operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
> { return __a = __a ^ __b; }
>
>
> enum _Ios_Seekdir
> {
> _S_beg = 0,
> _S_cur = 1,
> _S_end = 2,
> _S_ios_seekdir_end = 1L << 16
> };
># 199 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> class ios_base
> {
> public:
>
>
>
>
>
>
>
> class failure : public exception
> {
> public:
>
>
> explicit
> failure(const string& __str) throw();
>
>
>
> virtual
> ~failure() throw();
>
> virtual const char*
> what() const throw();
>
> private:
> string _M_msg;
> };
># 255 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> typedef _Ios_Fmtflags fmtflags;
>
>
> static const fmtflags boolalpha = _S_boolalpha;
>
>
> static const fmtflags dec = _S_dec;
>
>
> static const fmtflags fixed = _S_fixed;
>
>
> static const fmtflags hex = _S_hex;
>
>
>
>
> static const fmtflags internal = _S_internal;
>
>
>
> static const fmtflags left = _S_left;
>
>
> static const fmtflags oct = _S_oct;
>
>
>
> static const fmtflags right = _S_right;
>
>
> static const fmtflags scientific = _S_scientific;
>
>
>
> static const fmtflags showbase = _S_showbase;
>
>
>
> static const fmtflags showpoint = _S_showpoint;
>
>
> static const fmtflags showpos = _S_showpos;
>
>
> static const fmtflags skipws = _S_skipws;
>
>
> static const fmtflags unitbuf = _S_unitbuf;
>
>
>
> static const fmtflags uppercase = _S_uppercase;
>
>
> static const fmtflags adjustfield = _S_adjustfield;
>
>
> static const fmtflags basefield = _S_basefield;
>
>
> static const fmtflags floatfield = _S_floatfield;
># 330 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> typedef _Ios_Iostate iostate;
>
>
>
> static const iostate badbit = _S_badbit;
>
>
> static const iostate eofbit = _S_eofbit;
>
>
>
>
> static const iostate failbit = _S_failbit;
>
>
> static const iostate goodbit = _S_goodbit;
># 361 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> typedef _Ios_Openmode openmode;
>
>
> static const openmode app = _S_app;
>
>
> static const openmode ate = _S_ate;
>
>
>
>
> static const openmode binary = _S_bin;
>
>
> static const openmode in = _S_in;
>
>
> static const openmode out = _S_out;
>
>
> static const openmode trunc = _S_trunc;
># 393 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> typedef _Ios_Seekdir seekdir;
>
>
> static const seekdir beg = _S_beg;
>
>
> static const seekdir cur = _S_cur;
>
>
> static const seekdir end = _S_end;
>
>
> typedef int io_state;
> typedef int open_mode;
> typedef int seek_dir;
>
> typedef std::streampos streampos;
> typedef std::streamoff streamoff;
># 419 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> enum event
> {
> erase_event,
> imbue_event,
> copyfmt_event
> };
># 436 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> typedef void (*event_callback) (event __e, ios_base& __b, int __i);
># 448 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> void
> register_callback(event_callback __fn, int __index);
>
> protected:
> streamsize _M_precision;
> streamsize _M_width;
> fmtflags _M_flags;
> iostate _M_exception;
> iostate _M_streambuf_state;
>
>
>
> struct _Callback_list
> {
>
> _Callback_list* _M_next;
> ios_base::event_callback _M_fn;
> int _M_index;
> _Atomic_word _M_refcount;
>
> _Callback_list(ios_base::event_callback __fn, int __index,
> _Callback_list* __cb)
> : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
>
> void
> _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
>
>
> int
> _M_remove_reference()
> {
>
> ;
> int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
> if (__res == 0)
> {
> ;
> }
> return __res;
> }
> };
>
> _Callback_list* _M_callbacks;
>
> void
> _M_call_callbacks(event __ev) throw();
>
> void
> _M_dispose_callbacks(void) throw();
>
>
> struct _Words
> {
> void* _M_pword;
> long _M_iword;
> _Words() : _M_pword(0), _M_iword(0) { }
> };
>
>
> _Words _M_word_zero;
>
>
>
> enum { _S_local_word_size = 8 };
> _Words _M_local_word[_S_local_word_size];
>
>
> int _M_word_size;
> _Words* _M_word;
>
> _Words&
> _M_grow_words(int __index, bool __iword);
>
>
> locale _M_ios_locale;
>
> void
> _M_init() throw();
>
> public:
>
>
>
>
>
> class Init
> {
> friend class ios_base;
> public:
> Init();
> ~Init();
>
> private:
> static _Atomic_word _S_refcount;
> static bool _S_synced_with_stdio;
> };
>
>
>
>
>
>
> fmtflags
> flags() const
> { return _M_flags; }
># 561 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> fmtflags
> flags(fmtflags __fmtfl)
> {
> fmtflags __old = _M_flags;
> _M_flags = __fmtfl;
> return __old;
> }
># 577 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> fmtflags
> setf(fmtflags __fmtfl)
> {
> fmtflags __old = _M_flags;
> _M_flags |= __fmtfl;
> return __old;
> }
># 594 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> fmtflags
> setf(fmtflags __fmtfl, fmtflags __mask)
> {
> fmtflags __old = _M_flags;
> _M_flags &= ~__mask;
> _M_flags |= (__fmtfl & __mask);
> return __old;
> }
>
>
>
>
>
>
>
> void
> unsetf(fmtflags __mask)
> { _M_flags &= ~__mask; }
># 620 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> streamsize
> precision() const
> { return _M_precision; }
>
>
>
>
>
>
> streamsize
> precision(streamsize __prec)
> {
> streamsize __old = _M_precision;
> _M_precision = __prec;
> return __old;
> }
>
>
>
>
>
>
>
> streamsize
> width() const
> { return _M_width; }
>
>
>
>
>
>
> streamsize
> width(streamsize __wide)
> {
> streamsize __old = _M_width;
> _M_width = __wide;
> return __old;
> }
># 671 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> static bool
> sync_with_stdio(bool __sync = true);
># 683 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> locale
> imbue(const locale& __loc) throw();
># 694 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> locale
> getloc() const
> { return _M_ios_locale; }
># 705 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> const locale&
> _M_getloc() const
> { return _M_ios_locale; }
># 724 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> static int
> xalloc() throw();
># 740 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> long&
> iword(int __ix)
> {
> _Words& __word = (__ix < _M_word_size)
> ? _M_word[__ix] : _M_grow_words(__ix, true);
> return __word._M_iword;
> }
># 761 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> void*&
> pword(int __ix)
> {
> _Words& __word = (__ix < _M_word_size)
> ? _M_word[__ix] : _M_grow_words(__ix, false);
> return __word._M_pword;
> }
># 778 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
> virtual ~ios_base();
>
> protected:
> ios_base() throw ();
>
>
>
> private:
> ios_base(const ios_base&);
>
> ios_base&
> operator=(const ios_base&);
> };
>
>
>
> inline ios_base&
> boolalpha(ios_base& __base)
> {
> __base.setf(ios_base::boolalpha);
> return __base;
> }
>
>
> inline ios_base&
> noboolalpha(ios_base& __base)
> {
> __base.unsetf(ios_base::boolalpha);
> return __base;
> }
>
>
> inline ios_base&
> showbase(ios_base& __base)
> {
> __base.setf(ios_base::showbase);
> return __base;
> }
>
>
> inline ios_base&
> noshowbase(ios_base& __base)
> {
> __base.unsetf(ios_base::showbase);
> return __base;
> }
>
>
> inline ios_base&
> showpoint(ios_base& __base)
> {
> __base.setf(ios_base::showpoint);
> return __base;
> }
>
>
> inline ios_base&
> noshowpoint(ios_base& __base)
> {
> __base.unsetf(ios_base::showpoint);
> return __base;
> }
>
>
> inline ios_base&
> showpos(ios_base& __base)
> {
> __base.setf(ios_base::showpos);
> return __base;
> }
>
>
> inline ios_base&
> noshowpos(ios_base& __base)
> {
> __base.unsetf(ios_base::showpos);
> return __base;
> }
>
>
> inline ios_base&
> skipws(ios_base& __base)
> {
> __base.setf(ios_base::skipws);
> return __base;
> }
>
>
> inline ios_base&
> noskipws(ios_base& __base)
> {
> __base.unsetf(ios_base::skipws);
> return __base;
> }
>
>
> inline ios_base&
> uppercase(ios_base& __base)
> {
> __base.setf(ios_base::uppercase);
> return __base;
> }
>
>
> inline ios_base&
> nouppercase(ios_base& __base)
> {
> __base.unsetf(ios_base::uppercase);
> return __base;
> }
>
>
> inline ios_base&
> unitbuf(ios_base& __base)
> {
> __base.setf(ios_base::unitbuf);
> return __base;
> }
>
>
> inline ios_base&
> nounitbuf(ios_base& __base)
> {
> __base.unsetf(ios_base::unitbuf);
> return __base;
> }
>
>
>
> inline ios_base&
> internal(ios_base& __base)
> {
> __base.setf(ios_base::internal, ios_base::adjustfield);
> return __base;
> }
>
>
> inline ios_base&
> left(ios_base& __base)
> {
> __base.setf(ios_base::left, ios_base::adjustfield);
> return __base;
> }
>
>
> inline ios_base&
> right(ios_base& __base)
> {
> __base.setf(ios_base::right, ios_base::adjustfield);
> return __base;
> }
>
>
>
> inline ios_base&
> dec(ios_base& __base)
> {
> __base.setf(ios_base::dec, ios_base::basefield);
> return __base;
> }
>
>
> inline ios_base&
> hex(ios_base& __base)
> {
> __base.setf(ios_base::hex, ios_base::basefield);
> return __base;
> }
>
>
> inline ios_base&
> oct(ios_base& __base)
> {
> __base.setf(ios_base::oct, ios_base::basefield);
> return __base;
> }
>
>
>
> inline ios_base&
> fixed(ios_base& __base)
> {
> __base.setf(ios_base::fixed, ios_base::floatfield);
> return __base;
> }
>
>
> inline ios_base&
> scientific(ios_base& __base)
> {
> __base.setf(ios_base::scientific, ios_base::floatfield);
> return __base;
> }
>
>
>}
># 43 "/usr/include/c++/4.8.2/ios" 2 3
># 1 "/usr/include/c++/4.8.2/streambuf" 1 3
># 36 "/usr/include/c++/4.8.2/streambuf" 3
> 
># 37 "/usr/include/c++/4.8.2/streambuf" 3
># 45 "/usr/include/c++/4.8.2/streambuf" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> streamsize
> __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
> basic_streambuf<_CharT, _Traits>*, bool&);
># 119 "/usr/include/c++/4.8.2/streambuf" 3
> template<typename _CharT, typename _Traits>
> class basic_streambuf
> {
> public:
>
>
>
>
>
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
>
>
> typedef basic_streambuf<char_type, traits_type> __streambuf_type;
>
>
> friend class basic_ios<char_type, traits_type>;
> friend class basic_istream<char_type, traits_type>;
> friend class basic_ostream<char_type, traits_type>;
> friend class istreambuf_iterator<char_type, traits_type>;
> friend class ostreambuf_iterator<char_type, traits_type>;
>
> friend streamsize
> __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);
>
> template<bool _IsMove, typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> _CharT2*>::__type
> __copy_move_a2(istreambuf_iterator<_CharT2>,
> istreambuf_iterator<_CharT2>, _CharT2*);
>
> template<typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> istreambuf_iterator<_CharT2> >::__type
> find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
> const _CharT2&);
>
> template<typename _CharT2, typename _Traits2>
> friend basic_istream<_CharT2, _Traits2>&
> operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
>
> template<typename _CharT2, typename _Traits2, typename _Alloc>
> friend basic_istream<_CharT2, _Traits2>&
> operator>>(basic_istream<_CharT2, _Traits2>&,
> basic_string<_CharT2, _Traits2, _Alloc>&);
>
> template<typename _CharT2, typename _Traits2, typename _Alloc>
> friend basic_istream<_CharT2, _Traits2>&
> getline(basic_istream<_CharT2, _Traits2>&,
> basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
>
> protected:
>
>
>
>
>
>
>
> char_type* _M_in_beg;
> char_type* _M_in_cur;
> char_type* _M_in_end;
> char_type* _M_out_beg;
> char_type* _M_out_cur;
> char_type* _M_out_end;
>
>
> locale _M_buf_locale;
>
> public:
>
> virtual
> ~basic_streambuf()
> { }
># 208 "/usr/include/c++/4.8.2/streambuf" 3
> locale
> pubimbue(const locale& __loc)
> {
> locale __tmp(this->getloc());
> this->imbue(__loc);
> _M_buf_locale = __loc;
> return __tmp;
> }
># 225 "/usr/include/c++/4.8.2/streambuf" 3
> locale
> getloc() const
> { return _M_buf_locale; }
># 238 "/usr/include/c++/4.8.2/streambuf" 3
> basic_streambuf*
> pubsetbuf(char_type* __s, streamsize __n)
> { return this->setbuf(__s, __n); }
># 250 "/usr/include/c++/4.8.2/streambuf" 3
> pos_type
> pubseekoff(off_type __off, ios_base::seekdir __way,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> { return this->seekoff(__off, __way, __mode); }
># 262 "/usr/include/c++/4.8.2/streambuf" 3
> pos_type
> pubseekpos(pos_type __sp,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> { return this->seekpos(__sp, __mode); }
>
>
>
>
> int
> pubsync() { return this->sync(); }
># 283 "/usr/include/c++/4.8.2/streambuf" 3
> streamsize
> in_avail()
> {
> const streamsize __ret = this->egptr() - this->gptr();
> return __ret ? __ret : this->showmanyc();
> }
># 297 "/usr/include/c++/4.8.2/streambuf" 3
> int_type
> snextc()
> {
> int_type __ret = traits_type::eof();
> if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
> __ret), true))
> __ret = this->sgetc();
> return __ret;
> }
># 315 "/usr/include/c++/4.8.2/streambuf" 3
> int_type
> sbumpc()
> {
> int_type __ret;
> if (__builtin_expect(this->gptr() < this->egptr(), true))
> {
> __ret = traits_type::to_int_type(*this->gptr());
> this->gbump(1);
> }
> else
> __ret = this->uflow();
> return __ret;
> }
># 337 "/usr/include/c++/4.8.2/streambuf" 3
> int_type
> sgetc()
> {
> int_type __ret;
> if (__builtin_expect(this->gptr() < this->egptr(), true))
> __ret = traits_type::to_int_type(*this->gptr());
> else
> __ret = this->underflow();
> return __ret;
> }
># 356 "/usr/include/c++/4.8.2/streambuf" 3
> streamsize
> sgetn(char_type* __s, streamsize __n)
> { return this->xsgetn(__s, __n); }
># 371 "/usr/include/c++/4.8.2/streambuf" 3
> int_type
> sputbackc(char_type __c)
> {
> int_type __ret;
> const bool __testpos = this->eback() < this->gptr();
> if (__builtin_expect(!__testpos ||
> !traits_type::eq(__c, this->gptr()[-1]), false))
> __ret = this->pbackfail(traits_type::to_int_type(__c));
> else
> {
> this->gbump(-1);
> __ret = traits_type::to_int_type(*this->gptr());
> }
> return __ret;
> }
># 396 "/usr/include/c++/4.8.2/streambuf" 3
> int_type
> sungetc()
> {
> int_type __ret;
> if (__builtin_expect(this->eback() < this->gptr(), true))
> {
> this->gbump(-1);
> __ret = traits_type::to_int_type(*this->gptr());
> }
> else
> __ret = this->pbackfail();
> return __ret;
> }
># 423 "/usr/include/c++/4.8.2/streambuf" 3
> int_type
> sputc(char_type __c)
> {
> int_type __ret;
> if (__builtin_expect(this->pptr() < this->epptr(), true))
> {
> *this->pptr() = __c;
> this->pbump(1);
> __ret = traits_type::to_int_type(__c);
> }
> else
> __ret = this->overflow(traits_type::to_int_type(__c));
> return __ret;
> }
># 449 "/usr/include/c++/4.8.2/streambuf" 3
> streamsize
> sputn(const char_type* __s, streamsize __n)
> { return this->xsputn(__s, __n); }
>
> protected:
># 463 "/usr/include/c++/4.8.2/streambuf" 3
> basic_streambuf()
> : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
> _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
> _M_buf_locale(locale())
> { }
># 481 "/usr/include/c++/4.8.2/streambuf" 3
> char_type*
> eback() const { return _M_in_beg; }
>
> char_type*
> gptr() const { return _M_in_cur; }
>
> char_type*
> egptr() const { return _M_in_end; }
># 497 "/usr/include/c++/4.8.2/streambuf" 3
> void
> gbump(int __n) { _M_in_cur += __n; }
># 508 "/usr/include/c++/4.8.2/streambuf" 3
> void
> setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
> {
> _M_in_beg = __gbeg;
> _M_in_cur = __gnext;
> _M_in_end = __gend;
> }
># 528 "/usr/include/c++/4.8.2/streambuf" 3
> char_type*
> pbase() const { return _M_out_beg; }
>
> char_type*
> pptr() const { return _M_out_cur; }
>
> char_type*
> epptr() const { return _M_out_end; }
># 544 "/usr/include/c++/4.8.2/streambuf" 3
> void
> pbump(int __n) { _M_out_cur += __n; }
># 554 "/usr/include/c++/4.8.2/streambuf" 3
> void
> setp(char_type* __pbeg, char_type* __pend)
> {
> _M_out_beg = _M_out_cur = __pbeg;
> _M_out_end = __pend;
> }
># 575 "/usr/include/c++/4.8.2/streambuf" 3
> virtual void
> imbue(const locale& __loc)
> { }
># 590 "/usr/include/c++/4.8.2/streambuf" 3
> virtual basic_streambuf<char_type,_Traits>*
> setbuf(char_type*, streamsize)
> { return this; }
># 601 "/usr/include/c++/4.8.2/streambuf" 3
> virtual pos_type
> seekoff(off_type, ios_base::seekdir,
> ios_base::openmode = ios_base::in | ios_base::out)
> { return pos_type(off_type(-1)); }
># 613 "/usr/include/c++/4.8.2/streambuf" 3
> virtual pos_type
> seekpos(pos_type,
> ios_base::openmode = ios_base::in | ios_base::out)
> { return pos_type(off_type(-1)); }
># 626 "/usr/include/c++/4.8.2/streambuf" 3
> virtual int
> sync() { return 0; }
># 648 "/usr/include/c++/4.8.2/streambuf" 3
> virtual streamsize
> showmanyc() { return 0; }
># 664 "/usr/include/c++/4.8.2/streambuf" 3
> virtual streamsize
> xsgetn(char_type* __s, streamsize __n);
># 686 "/usr/include/c++/4.8.2/streambuf" 3
> virtual int_type
> underflow()
> { return traits_type::eof(); }
># 699 "/usr/include/c++/4.8.2/streambuf" 3
> virtual int_type
> uflow()
> {
> int_type __ret = traits_type::eof();
> const bool __testeof = traits_type::eq_int_type(this->underflow(),
> __ret);
> if (!__testeof)
> {
> __ret = traits_type::to_int_type(*this->gptr());
> this->gbump(1);
> }
> return __ret;
> }
># 723 "/usr/include/c++/4.8.2/streambuf" 3
> virtual int_type
> pbackfail(int_type __c = traits_type::eof())
> { return traits_type::eof(); }
># 741 "/usr/include/c++/4.8.2/streambuf" 3
> virtual streamsize
> xsputn(const char_type* __s, streamsize __n);
># 767 "/usr/include/c++/4.8.2/streambuf" 3
> virtual int_type
> overflow(int_type __c = traits_type::eof())
> { return traits_type::eof(); }
>
>
>
> public:
># 782 "/usr/include/c++/4.8.2/streambuf" 3
> void
> stossc()
> {
> if (this->gptr() < this->egptr())
> this->gbump(1);
> else
> this->uflow();
> }
>
>
>
> void
> __safe_gbump(streamsize __n) { _M_in_cur += __n; }
>
> void
> __safe_pbump(streamsize __n) { _M_out_cur += __n; }
>
> private:
>
>
> basic_streambuf(const basic_streambuf& __sb)
> : _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur),
> _M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg),
> _M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
> _M_buf_locale(__sb._M_buf_locale)
> { }
>
> basic_streambuf&
> operator=(const basic_streambuf&) { return *this; };
> };
>
>
> template<>
> streamsize
> __copy_streambufs_eof(basic_streambuf<char>* __sbin,
> basic_streambuf<char>* __sbout, bool& __ineof);
>
> template<>
> streamsize
> __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
> basic_streambuf<wchar_t>* __sbout, bool& __ineof);
>
>
>
>}
>
># 1 "/usr/include/c++/4.8.2/bits/streambuf.tcc" 1 3
># 37 "/usr/include/c++/4.8.2/bits/streambuf.tcc" 3
> 
># 38 "/usr/include/c++/4.8.2/bits/streambuf.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> streamsize
> basic_streambuf<_CharT, _Traits>::
> xsgetn(char_type* __s, streamsize __n)
> {
> streamsize __ret = 0;
> while (__ret < __n)
> {
> const streamsize __buf_len = this->egptr() - this->gptr();
> if (__buf_len)
> {
> const streamsize __remaining = __n - __ret;
> const streamsize __len = std::min(__buf_len, __remaining);
> traits_type::copy(__s, this->gptr(), __len);
> __ret += __len;
> __s += __len;
> this->__safe_gbump(__len);
> }
>
> if (__ret < __n)
> {
> const int_type __c = this->uflow();
> if (!traits_type::eq_int_type(__c, traits_type::eof()))
> {
> traits_type::assign(*__s++, traits_type::to_char_type(__c));
> ++__ret;
> }
> else
> break;
> }
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> streamsize
> basic_streambuf<_CharT, _Traits>::
> xsputn(const char_type* __s, streamsize __n)
> {
> streamsize __ret = 0;
> while (__ret < __n)
> {
> const streamsize __buf_len = this->epptr() - this->pptr();
> if (__buf_len)
> {
> const streamsize __remaining = __n - __ret;
> const streamsize __len = std::min(__buf_len, __remaining);
> traits_type::copy(this->pptr(), __s, __len);
> __ret += __len;
> __s += __len;
> this->__safe_pbump(__len);
> }
>
> if (__ret < __n)
> {
> int_type __c = this->overflow(traits_type::to_int_type(*__s));
> if (!traits_type::eq_int_type(__c, traits_type::eof()))
> {
> ++__ret;
> ++__s;
> }
> else
> break;
> }
> }
> return __ret;
> }
>
>
>
>
> template<typename _CharT, typename _Traits>
> streamsize
> __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
> basic_streambuf<_CharT, _Traits>* __sbout,
> bool& __ineof)
> {
> streamsize __ret = 0;
> __ineof = true;
> typename _Traits::int_type __c = __sbin->sgetc();
> while (!_Traits::eq_int_type(__c, _Traits::eof()))
> {
> __c = __sbout->sputc(_Traits::to_char_type(__c));
> if (_Traits::eq_int_type(__c, _Traits::eof()))
> {
> __ineof = false;
> break;
> }
> ++__ret;
> __c = __sbin->snextc();
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> inline streamsize
> __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
> basic_streambuf<_CharT, _Traits>* __sbout)
> {
> bool __ineof;
> return __copy_streambufs_eof(__sbin, __sbout, __ineof);
> }
>
>
>
>
> extern template class basic_streambuf<char>;
> extern template
> streamsize
> __copy_streambufs(basic_streambuf<char>*,
> basic_streambuf<char>*);
> extern template
> streamsize
> __copy_streambufs_eof(basic_streambuf<char>*,
> basic_streambuf<char>*, bool&);
>
>
> extern template class basic_streambuf<wchar_t>;
> extern template
> streamsize
> __copy_streambufs(basic_streambuf<wchar_t>*,
> basic_streambuf<wchar_t>*);
> extern template
> streamsize
> __copy_streambufs_eof(basic_streambuf<wchar_t>*,
> basic_streambuf<wchar_t>*, bool&);
>
>
>
>
>}
># 829 "/usr/include/c++/4.8.2/streambuf" 2 3
># 44 "/usr/include/c++/4.8.2/ios" 2 3
># 1 "/usr/include/c++/4.8.2/bits/basic_ios.h" 1 3
># 33 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
> 
># 34 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/locale_facets.h" 1 3
># 37 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> 
># 38 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
>
># 1 "/usr/include/c++/4.8.2/cwctype" 1 3
># 39 "/usr/include/c++/4.8.2/cwctype" 3
> 
># 40 "/usr/include/c++/4.8.2/cwctype" 3
># 50 "/usr/include/c++/4.8.2/cwctype" 3
># 1 "/usr/include/wctype.h" 1 3 4
># 33 "/usr/include/wctype.h" 3 4
># 1 "/usr/include/wchar.h" 1 3 4
># 34 "/usr/include/wctype.h" 2 3 4
># 49 "/usr/include/wctype.h" 3 4
>
>
>
>typedef unsigned long int wctype_t;
>
># 71 "/usr/include/wctype.h" 3 4
>enum
>{
> __ISwupper = 0,
> __ISwlower = 1,
> __ISwalpha = 2,
> __ISwdigit = 3,
> __ISwxdigit = 4,
> __ISwspace = 5,
> __ISwprint = 6,
> __ISwgraph = 7,
> __ISwblank = 8,
> __ISwcntrl = 9,
> __ISwpunct = 10,
> __ISwalnum = 11,
>
> _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
> _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
> _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
> _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
> _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
> _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
> _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
> _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
> _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
> _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
> _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
> _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
>};
>
>
>
>extern "C" {
>
>
>
>
>
>
>
>
>extern int iswalnum (wint_t __wc) throw ();
>
>
>
>
>
>extern int iswalpha (wint_t __wc) throw ();
>
>
>extern int iswcntrl (wint_t __wc) throw ();
>
>
>
>extern int iswdigit (wint_t __wc) throw ();
>
>
>
>extern int iswgraph (wint_t __wc) throw ();
>
>
>
>
>extern int iswlower (wint_t __wc) throw ();
>
>
>extern int iswprint (wint_t __wc) throw ();
>
>
>
>
>extern int iswpunct (wint_t __wc) throw ();
>
>
>
>
>extern int iswspace (wint_t __wc) throw ();
>
>
>
>
>extern int iswupper (wint_t __wc) throw ();
>
>
>
>
>extern int iswxdigit (wint_t __wc) throw ();
>
>
>
>
>
>extern int iswblank (wint_t __wc) throw ();
># 171 "/usr/include/wctype.h" 3 4
>extern wctype_t wctype (const char *__property) throw ();
>
>
>
>extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
>
>
>
>
>
>
>
>
>
>
>typedef const __int32_t *wctrans_t;
>
>
>
>
>
>
>
>extern wint_t towlower (wint_t __wc) throw ();
>
>
>extern wint_t towupper (wint_t __wc) throw ();
>
>
>}
># 213 "/usr/include/wctype.h" 3 4
>extern "C" {
>
>
>
>
>extern wctrans_t wctrans (const char *__property) throw ();
>
>
>extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
>
>
>
>
>
>
>
>
>extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>
>extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>
>extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>extern wctype_t wctype_l (const char *__property, __locale_t __locale)
> throw ();
>
>
>
>extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
> throw ();
>
>
>
>
>
>
>
>extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();
>
>
>
>extern wctrans_t wctrans_l (const char *__property, __locale_t __locale)
> throw ();
>
>
>extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
> __locale_t __locale) throw ();
>
>
>
>}
># 51 "/usr/include/c++/4.8.2/cwctype" 2 3
># 80 "/usr/include/c++/4.8.2/cwctype" 3
>namespace std
>{
> using ::wctrans_t;
> using ::wctype_t;
> using ::wint_t;
>
> using ::iswalnum;
> using ::iswalpha;
>
> using ::iswblank;
>
> using ::iswcntrl;
> using ::iswctype;
> using ::iswdigit;
> using ::iswgraph;
> using ::iswlower;
> using ::iswprint;
> using ::iswpunct;
> using ::iswspace;
> using ::iswupper;
> using ::iswxdigit;
> using ::towctrans;
> using ::towlower;
> using ::towupper;
> using ::wctrans;
> using ::wctype;
>}
># 40 "/usr/include/c++/4.8.2/bits/locale_facets.h" 2 3
># 1 "/usr/include/c++/4.8.2/cctype" 1 3
># 39 "/usr/include/c++/4.8.2/cctype" 3
> 
># 40 "/usr/include/c++/4.8.2/cctype" 3
># 41 "/usr/include/c++/4.8.2/bits/locale_facets.h" 2 3
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/ctype_base.h" 1 3
># 36 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/ctype_base.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> struct ctype_base
> {
>
> typedef const int* __to_type;
>
>
>
> typedef unsigned short mask;
> static const mask upper = _ISupper;
> static const mask lower = _ISlower;
> static const mask alpha = _ISalpha;
> static const mask digit = _ISdigit;
> static const mask xdigit = _ISxdigit;
> static const mask space = _ISspace;
> static const mask print = _ISprint;
> static const mask graph = _ISalpha | _ISdigit | _ISpunct;
> static const mask cntrl = _IScntrl;
> static const mask punct = _ISpunct;
> static const mask alnum = _ISalpha | _ISdigit;
> };
>
>
>}
># 42 "/usr/include/c++/4.8.2/bits/locale_facets.h" 2 3
>
>
>
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/streambuf_iterator.h" 1 3
># 33 "/usr/include/c++/4.8.2/bits/streambuf_iterator.h" 3
> 
># 34 "/usr/include/c++/4.8.2/bits/streambuf_iterator.h" 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 49 "/usr/include/c++/4.8.2/bits/streambuf_iterator.h" 3
> template<typename _CharT, typename _Traits>
> class istreambuf_iterator
> : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
> _CharT*,
>
>
> _CharT>
>
>
>
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef typename _Traits::int_type int_type;
> typedef basic_streambuf<_CharT, _Traits> streambuf_type;
> typedef basic_istream<_CharT, _Traits> istream_type;
>
>
> template<typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> ostreambuf_iterator<_CharT2> >::__type
> copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
> ostreambuf_iterator<_CharT2>);
>
> template<bool _IsMove, typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> _CharT2*>::__type
> __copy_move_a2(istreambuf_iterator<_CharT2>,
> istreambuf_iterator<_CharT2>, _CharT2*);
>
> template<typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> istreambuf_iterator<_CharT2> >::__type
> find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
> const _CharT2&);
>
> private:
>
>
>
>
>
>
>
> mutable streambuf_type* _M_sbuf;
> mutable int_type _M_c;
>
> public:
>
> constexpr istreambuf_iterator() noexcept
> : _M_sbuf(0), _M_c(traits_type::eof()) { }
>
>
> istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
>
> ~istreambuf_iterator() = default;
>
>
>
> istreambuf_iterator(istream_type& __s) noexcept
> : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
>
>
> istreambuf_iterator(streambuf_type* __s) noexcept
> : _M_sbuf(__s), _M_c(traits_type::eof()) { }
>
>
>
>
> char_type
> operator*() const
> {
>
>
>
>
>
>
>
> return traits_type::to_char_type(_M_get());
> }
>
>
> istreambuf_iterator&
> operator++()
> {
>
>
> ;
> if (_M_sbuf)
> {
> _M_sbuf->sbumpc();
> _M_c = traits_type::eof();
> }
> return *this;
> }
>
>
> istreambuf_iterator
> operator++(int)
> {
>
>
> ;
>
> istreambuf_iterator __old = *this;
> if (_M_sbuf)
> {
> __old._M_c = _M_sbuf->sbumpc();
> _M_c = traits_type::eof();
> }
> return __old;
> }
>
>
>
>
>
> bool
> equal(const istreambuf_iterator& __b) const
> { return _M_at_eof() == __b._M_at_eof(); }
>
> private:
> int_type
> _M_get() const
> {
> const int_type __eof = traits_type::eof();
> int_type __ret = __eof;
> if (_M_sbuf)
> {
> if (!traits_type::eq_int_type(_M_c, __eof))
> __ret = _M_c;
> else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
> __eof))
> _M_c = __ret;
> else
> _M_sbuf = 0;
> }
> return __ret;
> }
>
> bool
> _M_at_eof() const
> {
> const int_type __eof = traits_type::eof();
> return traits_type::eq_int_type(_M_get(), __eof);
> }
> };
>
> template<typename _CharT, typename _Traits>
> inline bool
> operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
> const istreambuf_iterator<_CharT, _Traits>& __b)
> { return __a.equal(__b); }
>
> template<typename _CharT, typename _Traits>
> inline bool
> operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
> const istreambuf_iterator<_CharT, _Traits>& __b)
> { return !__a.equal(__b); }
>
>
> template<typename _CharT, typename _Traits>
> class ostreambuf_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef basic_streambuf<_CharT, _Traits> streambuf_type;
> typedef basic_ostream<_CharT, _Traits> ostream_type;
>
>
> template<typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> ostreambuf_iterator<_CharT2> >::__type
> copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
> ostreambuf_iterator<_CharT2>);
>
> private:
> streambuf_type* _M_sbuf;
> bool _M_failed;
>
> public:
>
> ostreambuf_iterator(ostream_type& __s) noexcept
> : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
>
>
> ostreambuf_iterator(streambuf_type* __s) noexcept
> : _M_sbuf(__s), _M_failed(!_M_sbuf) { }
>
>
> ostreambuf_iterator&
> operator=(_CharT __c)
> {
> if (!_M_failed &&
> _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
> _M_failed = true;
> return *this;
> }
>
>
> ostreambuf_iterator&
> operator*()
> { return *this; }
>
>
> ostreambuf_iterator&
> operator++(int)
> { return *this; }
>
>
> ostreambuf_iterator&
> operator++()
> { return *this; }
>
>
> bool
> failed() const noexcept
> { return _M_failed; }
>
> ostreambuf_iterator&
> _M_put(const _CharT* __ws, streamsize __len)
> {
> if (__builtin_expect(!_M_failed, true)
> && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
> false))
> _M_failed = true;
> return *this;
> }
> };
>
>
> template<typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> ostreambuf_iterator<_CharT> >::__type
> copy(istreambuf_iterator<_CharT> __first,
> istreambuf_iterator<_CharT> __last,
> ostreambuf_iterator<_CharT> __result)
> {
> if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
> {
> bool __ineof;
> __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
> if (!__ineof)
> __result._M_failed = true;
> }
> return __result;
> }
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> ostreambuf_iterator<_CharT> >::__type
> __copy_move_a2(_CharT* __first, _CharT* __last,
> ostreambuf_iterator<_CharT> __result)
> {
> const streamsize __num = __last - __first;
> if (__num > 0)
> __result._M_put(__first, __num);
> return __result;
> }
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> ostreambuf_iterator<_CharT> >::__type
> __copy_move_a2(const _CharT* __first, const _CharT* __last,
> ostreambuf_iterator<_CharT> __result)
> {
> const streamsize __num = __last - __first;
> if (__num > 0)
> __result._M_put(__first, __num);
> return __result;
> }
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> _CharT*>::__type
> __copy_move_a2(istreambuf_iterator<_CharT> __first,
> istreambuf_iterator<_CharT> __last, _CharT* __result)
> {
> typedef istreambuf_iterator<_CharT> __is_iterator_type;
> typedef typename __is_iterator_type::traits_type traits_type;
> typedef typename __is_iterator_type::streambuf_type streambuf_type;
> typedef typename traits_type::int_type int_type;
>
> if (__first._M_sbuf && !__last._M_sbuf)
> {
> streambuf_type* __sb = __first._M_sbuf;
> int_type __c = __sb->sgetc();
> while (!traits_type::eq_int_type(__c, traits_type::eof()))
> {
> const streamsize __n = __sb->egptr() - __sb->gptr();
> if (__n > 1)
> {
> traits_type::copy(__result, __sb->gptr(), __n);
> __sb->__safe_gbump(__n);
> __result += __n;
> __c = __sb->underflow();
> }
> else
> {
> *__result++ = traits_type::to_char_type(__c);
> __c = __sb->snextc();
> }
> }
> }
> return __result;
> }
>
> template<typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> istreambuf_iterator<_CharT> >::__type
> find(istreambuf_iterator<_CharT> __first,
> istreambuf_iterator<_CharT> __last, const _CharT& __val)
> {
> typedef istreambuf_iterator<_CharT> __is_iterator_type;
> typedef typename __is_iterator_type::traits_type traits_type;
> typedef typename __is_iterator_type::streambuf_type streambuf_type;
> typedef typename traits_type::int_type int_type;
>
> if (__first._M_sbuf && !__last._M_sbuf)
> {
> const int_type __ival = traits_type::to_int_type(__val);
> streambuf_type* __sb = __first._M_sbuf;
> int_type __c = __sb->sgetc();
> while (!traits_type::eq_int_type(__c, traits_type::eof())
> && !traits_type::eq_int_type(__c, __ival))
> {
> streamsize __n = __sb->egptr() - __sb->gptr();
> if (__n > 1)
> {
> const _CharT* __p = traits_type::find(__sb->gptr(),
> __n, __val);
> if (__p)
> __n = __p - __sb->gptr();
> __sb->__safe_gbump(__n);
> __c = __sb->sgetc();
> }
> else
> __c = __sb->snextc();
> }
>
> if (!traits_type::eq_int_type(__c, traits_type::eof()))
> __first._M_c = __c;
> else
> __first._M_sbuf = 0;
> }
> return __first;
> }
>
>
>
>
>}
># 49 "/usr/include/c++/4.8.2/bits/locale_facets.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 64 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> template<typename _Tp>
> void
> __convert_to_v(const char*, _Tp&, ios_base::iostate&,
> const __c_locale&) throw();
>
>
> template<>
> void
> __convert_to_v(const char*, float&, ios_base::iostate&,
> const __c_locale&) throw();
>
> template<>
> void
> __convert_to_v(const char*, double&, ios_base::iostate&,
> const __c_locale&) throw();
>
> template<>
> void
> __convert_to_v(const char*, long double&, ios_base::iostate&,
> const __c_locale&) throw();
>
>
>
> template<typename _CharT, typename _Traits>
> struct __pad
> {
> static void
> _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
> const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
> };
>
>
>
>
>
>
> template<typename _CharT>
> _CharT*
> __add_grouping(_CharT* __s, _CharT __sep,
> const char* __gbeg, size_t __gsize,
> const _CharT* __first, const _CharT* __last);
>
>
>
>
> template<typename _CharT>
> inline
> ostreambuf_iterator<_CharT>
> __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
> {
> __s._M_put(__ws, __len);
> return __s;
> }
>
>
> template<typename _CharT, typename _OutIter>
> inline
> _OutIter
> __write(_OutIter __s, const _CharT* __ws, int __len)
> {
> for (int __j = 0; __j < __len; __j++, ++__s)
> *__s = __ws[__j];
> return __s;
> }
># 142 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> template<typename _CharT>
> class __ctype_abstract_base : public locale::facet, public ctype_base
> {
> public:
>
>
> typedef _CharT char_type;
># 161 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> bool
> is(mask __m, char_type __c) const
> { return this->do_is(__m, __c); }
># 178 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> const char_type*
> is(const char_type *__lo, const char_type *__hi, mask *__vec) const
> { return this->do_is(__lo, __hi, __vec); }
># 194 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> const char_type*
> scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
> { return this->do_scan_is(__m, __lo, __hi); }
># 210 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> const char_type*
> scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
> { return this->do_scan_not(__m, __lo, __hi); }
># 224 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> char_type
> toupper(char_type __c) const
> { return this->do_toupper(__c); }
># 239 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> const char_type*
> toupper(char_type *__lo, const char_type* __hi) const
> { return this->do_toupper(__lo, __hi); }
># 253 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> char_type
> tolower(char_type __c) const
> { return this->do_tolower(__c); }
># 268 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> const char_type*
> tolower(char_type* __lo, const char_type* __hi) const
> { return this->do_tolower(__lo, __hi); }
># 285 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> char_type
> widen(char __c) const
> { return this->do_widen(__c); }
># 304 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> const char*
> widen(const char* __lo, const char* __hi, char_type* __to) const
> { return this->do_widen(__lo, __hi, __to); }
># 323 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> char
> narrow(char_type __c, char __dfault) const
> { return this->do_narrow(__c, __dfault); }
># 345 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> const char_type*
> narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char* __to) const
> { return this->do_narrow(__lo, __hi, __dfault, __to); }
>
> protected:
> explicit
> __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
>
> virtual
> ~__ctype_abstract_base() { }
># 370 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual bool
> do_is(mask __m, char_type __c) const = 0;
># 389 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char_type*
> do_is(const char_type* __lo, const char_type* __hi,
> mask* __vec) const = 0;
># 408 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_is(mask __m, const char_type* __lo,
> const char_type* __hi) const = 0;
># 427 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_not(mask __m, const char_type* __lo,
> const char_type* __hi) const = 0;
># 445 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual char_type
> do_toupper(char_type __c) const = 0;
># 462 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const = 0;
># 478 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual char_type
> do_tolower(char_type __c) const = 0;
># 495 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const = 0;
># 514 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual char_type
> do_widen(char __c) const = 0;
># 535 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char*
> do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
># 556 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual char
> do_narrow(char_type __c, char __dfault) const = 0;
># 581 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char_type*
> do_narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char* __to) const = 0;
> };
># 604 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> template<typename _CharT>
> class ctype : public __ctype_abstract_base<_CharT>
> {
> public:
>
> typedef _CharT char_type;
> typedef typename __ctype_abstract_base<_CharT>::mask mask;
>
>
> static locale::id id;
>
> explicit
> ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
>
> protected:
> virtual
> ~ctype();
>
> virtual bool
> do_is(mask __m, char_type __c) const;
>
> virtual const char_type*
> do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
>
> virtual const char_type*
> do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
>
> virtual const char_type*
> do_scan_not(mask __m, const char_type* __lo,
> const char_type* __hi) const;
>
> virtual char_type
> do_toupper(char_type __c) const;
>
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const;
>
> virtual char_type
> do_tolower(char_type __c) const;
>
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const;
>
> virtual char_type
> do_widen(char __c) const;
>
> virtual const char*
> do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
>
> virtual char
> do_narrow(char_type, char __dfault) const;
>
> virtual const char_type*
> do_narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char* __to) const;
> };
>
> template<typename _CharT>
> locale::id ctype<_CharT>::id;
># 673 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> template<>
> class ctype<char> : public locale::facet, public ctype_base
> {
> public:
>
>
> typedef char char_type;
>
> protected:
>
> __c_locale _M_c_locale_ctype;
> bool _M_del;
> __to_type _M_toupper;
> __to_type _M_tolower;
> const mask* _M_table;
> mutable char _M_widen_ok;
> mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
> mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
> mutable char _M_narrow_ok;
>
>
> public:
>
> static locale::id id;
>
> static const size_t table_size = 1 + static_cast<unsigned char>(-1);
># 710 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> explicit
> ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
># 723 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> explicit
> ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
> size_t __refs = 0);
># 736 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> inline bool
> is(mask __m, char __c) const;
># 751 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> inline const char*
> is(const char* __lo, const char* __hi, mask* __vec) const;
># 765 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> inline const char*
> scan_is(mask __m, const char* __lo, const char* __hi) const;
># 779 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> inline const char*
> scan_not(mask __m, const char* __lo, const char* __hi) const;
># 794 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> char_type
> toupper(char_type __c) const
> { return this->do_toupper(__c); }
># 811 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> const char_type*
> toupper(char_type *__lo, const char_type* __hi) const
> { return this->do_toupper(__lo, __hi); }
># 827 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> char_type
> tolower(char_type __c) const
> { return this->do_tolower(__c); }
># 844 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> const char_type*
> tolower(char_type* __lo, const char_type* __hi) const
> { return this->do_tolower(__lo, __hi); }
># 864 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> char_type
> widen(char __c) const
> {
> if (_M_widen_ok)
> return _M_widen[static_cast<unsigned char>(__c)];
> this->_M_widen_init();
> return this->do_widen(__c);
> }
># 891 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> const char*
> widen(const char* __lo, const char* __hi, char_type* __to) const
> {
> if (_M_widen_ok == 1)
> {
> __builtin_memcpy(__to, __lo, __hi - __lo);
> return __hi;
> }
> if (!_M_widen_ok)
> _M_widen_init();
> return this->do_widen(__lo, __hi, __to);
> }
># 922 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> char
> narrow(char_type __c, char __dfault) const
> {
> if (_M_narrow[static_cast<unsigned char>(__c)])
> return _M_narrow[static_cast<unsigned char>(__c)];
> const char __t = do_narrow(__c, __dfault);
> if (__t != __dfault)
> _M_narrow[static_cast<unsigned char>(__c)] = __t;
> return __t;
> }
># 955 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> const char_type*
> narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char* __to) const
> {
> if (__builtin_expect(_M_narrow_ok == 1, true))
> {
> __builtin_memcpy(__to, __lo, __hi - __lo);
> return __hi;
> }
> if (!_M_narrow_ok)
> _M_narrow_init();
> return this->do_narrow(__lo, __hi, __dfault, __to);
> }
>
>
>
>
>
> const mask*
> table() const throw()
> { return _M_table; }
>
>
> static const mask*
> classic_table() throw();
> protected:
>
>
>
>
>
>
>
> virtual
> ~ctype();
># 1004 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual char_type
> do_toupper(char_type __c) const;
># 1021 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const;
># 1037 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual char_type
> do_tolower(char_type __c) const;
># 1054 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const;
># 1074 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual char_type
> do_widen(char __c) const
> { return __c; }
># 1097 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char*
> do_widen(const char* __lo, const char* __hi, char_type* __to) const
> {
> __builtin_memcpy(__to, __lo, __hi - __lo);
> return __hi;
> }
># 1123 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual char
> do_narrow(char_type __c, char __dfault) const
> { return __c; }
># 1149 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char_type*
> do_narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char* __to) const
> {
> __builtin_memcpy(__to, __lo, __hi - __lo);
> return __hi;
> }
>
> private:
> void _M_narrow_init() const;
> void _M_widen_init() const;
> };
># 1174 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> template<>
> class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
> {
> public:
>
>
> typedef wchar_t char_type;
> typedef wctype_t __wmask_type;
>
> protected:
> __c_locale _M_c_locale_ctype;
>
>
> bool _M_narrow_ok;
> char _M_narrow[128];
> wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
>
>
> mask _M_bit[16];
> __wmask_type _M_wmask[16];
>
> public:
>
>
> static locale::id id;
># 1207 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> explicit
> ctype(size_t __refs = 0);
># 1218 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> explicit
> ctype(__c_locale __cloc, size_t __refs = 0);
>
> protected:
> __wmask_type
> _M_convert_to_wmask(const mask __m) const throw();
>
>
> virtual
> ~ctype();
># 1242 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual bool
> do_is(mask __m, char_type __c) const;
># 1261 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char_type*
> do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
># 1279 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
># 1297 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_not(mask __m, const char_type* __lo,
> const char_type* __hi) const;
># 1314 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual char_type
> do_toupper(char_type __c) const;
># 1331 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const;
># 1347 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual char_type
> do_tolower(char_type __c) const;
># 1364 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const;
># 1384 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual char_type
> do_widen(char __c) const;
># 1406 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char*
> do_widen(const char* __lo, const char* __hi, char_type* __to) const;
># 1429 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual char
> do_narrow(char_type __c, char __dfault) const;
># 1455 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual const char_type*
> do_narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char* __to) const;
>
>
> void
> _M_initialize_ctype() throw();
> };
>
>
>
> template<typename _CharT>
> class ctype_byname : public ctype<_CharT>
> {
> public:
> typedef typename ctype<_CharT>::mask mask;
>
> explicit
> ctype_byname(const char* __s, size_t __refs = 0);
>
> protected:
> virtual
> ~ctype_byname() { };
> };
>
>
> template<>
> class ctype_byname<char> : public ctype<char>
> {
> public:
> explicit
> ctype_byname(const char* __s, size_t __refs = 0);
>
> protected:
> virtual
> ~ctype_byname();
> };
>
>
> template<>
> class ctype_byname<wchar_t> : public ctype<wchar_t>
> {
> public:
> explicit
> ctype_byname(const char* __s, size_t __refs = 0);
>
> protected:
> virtual
> ~ctype_byname();
> };
>
>
>
>}
>
>
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/ctype_inline.h" 1 3
># 37 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/ctype_inline.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> bool
> ctype<char>::
> is(mask __m, char __c) const
> { return _M_table[static_cast<unsigned char>(__c)] & __m; }
>
> const char*
> ctype<char>::
> is(const char* __low, const char* __high, mask* __vec) const
> {
> while (__low < __high)
> *__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
> return __high;
> }
>
> const char*
> ctype<char>::
> scan_is(mask __m, const char* __low, const char* __high) const
> {
> while (__low < __high
> && !(_M_table[static_cast<unsigned char>(*__low)] & __m))
> ++__low;
> return __low;
> }
>
> const char*
> ctype<char>::
> scan_not(mask __m, const char* __low, const char* __high) const
> {
> while (__low < __high
> && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
> ++__low;
> return __low;
> }
>
>
>}
># 1512 "/usr/include/c++/4.8.2/bits/locale_facets.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> class __num_base
> {
> public:
>
>
> enum
> {
> _S_ominus,
> _S_oplus,
> _S_ox,
> _S_oX,
> _S_odigits,
> _S_odigits_end = _S_odigits + 16,
> _S_oudigits = _S_odigits_end,
> _S_oudigits_end = _S_oudigits + 16,
> _S_oe = _S_odigits + 14,
> _S_oE = _S_oudigits + 14,
> _S_oend = _S_oudigits_end
> };
>
>
>
>
>
>
> static const char* _S_atoms_out;
>
>
>
> static const char* _S_atoms_in;
>
> enum
> {
> _S_iminus,
> _S_iplus,
> _S_ix,
> _S_iX,
> _S_izero,
> _S_ie = _S_izero + 14,
> _S_iE = _S_izero + 20,
> _S_iend = 26
> };
>
>
>
> static void
> _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
> };
>
> template<typename _CharT>
> struct __numpunct_cache : public locale::facet
> {
> const char* _M_grouping;
> size_t _M_grouping_size;
> bool _M_use_grouping;
> const _CharT* _M_truename;
> size_t _M_truename_size;
> const _CharT* _M_falsename;
> size_t _M_falsename_size;
> _CharT _M_decimal_point;
> _CharT _M_thousands_sep;
>
>
>
>
>
> _CharT _M_atoms_out[__num_base::_S_oend];
>
>
>
>
>
> _CharT _M_atoms_in[__num_base::_S_iend];
>
> bool _M_allocated;
>
> __numpunct_cache(size_t __refs = 0)
> : facet(__refs), _M_grouping(0), _M_grouping_size(0),
> _M_use_grouping(false),
> _M_truename(0), _M_truename_size(0), _M_falsename(0),
> _M_falsename_size(0), _M_decimal_point(_CharT()),
> _M_thousands_sep(_CharT()), _M_allocated(false)
> { }
>
> ~__numpunct_cache();
>
> void
> _M_cache(const locale& __loc);
>
> private:
> __numpunct_cache&
> operator=(const __numpunct_cache&);
>
> explicit
> __numpunct_cache(const __numpunct_cache&);
> };
>
> template<typename _CharT>
> __numpunct_cache<_CharT>::~__numpunct_cache()
> {
> if (_M_allocated)
> {
> delete [] _M_grouping;
> delete [] _M_truename;
> delete [] _M_falsename;
> }
> }
># 1640 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> template<typename _CharT>
> class numpunct : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
> typedef __numpunct_cache<_CharT> __cache_type;
>
> protected:
> __cache_type* _M_data;
>
> public:
>
> static locale::id id;
>
>
>
>
>
>
> explicit
> numpunct(size_t __refs = 0)
> : facet(__refs), _M_data(0)
> { _M_initialize_numpunct(); }
># 1678 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> explicit
> numpunct(__cache_type* __cache, size_t __refs = 0)
> : facet(__refs), _M_data(__cache)
> { _M_initialize_numpunct(); }
># 1692 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> explicit
> numpunct(__c_locale __cloc, size_t __refs = 0)
> : facet(__refs), _M_data(0)
> { _M_initialize_numpunct(__cloc); }
># 1706 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> char_type
> decimal_point() const
> { return this->do_decimal_point(); }
># 1719 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> char_type
> thousands_sep() const
> { return this->do_thousands_sep(); }
># 1750 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> string
> grouping() const
> { return this->do_grouping(); }
># 1763 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> string_type
> truename() const
> { return this->do_truename(); }
># 1776 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> string_type
> falsename() const
> { return this->do_falsename(); }
>
> protected:
>
> virtual
> ~numpunct();
># 1793 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual char_type
> do_decimal_point() const
> { return _M_data->_M_decimal_point; }
># 1805 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual char_type
> do_thousands_sep() const
> { return _M_data->_M_thousands_sep; }
># 1818 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual string
> do_grouping() const
> { return _M_data->_M_grouping; }
># 1831 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual string_type
> do_truename() const
> { return _M_data->_M_truename; }
># 1844 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual string_type
> do_falsename() const
> { return _M_data->_M_falsename; }
>
>
> void
> _M_initialize_numpunct(__c_locale __cloc = 0);
> };
>
> template<typename _CharT>
> locale::id numpunct<_CharT>::id;
>
> template<>
> numpunct<char>::~numpunct();
>
> template<>
> void
> numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
>
>
> template<>
> numpunct<wchar_t>::~numpunct();
>
> template<>
> void
> numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
>
>
>
> template<typename _CharT>
> class numpunct_byname : public numpunct<_CharT>
> {
> public:
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
> explicit
> numpunct_byname(const char* __s, size_t __refs = 0)
> : numpunct<_CharT>(__refs)
> {
> if (__builtin_strcmp(__s, "C") != 0
> && __builtin_strcmp(__s, "POSIX") != 0)
> {
> __c_locale __tmp;
> this->_S_create_c_locale(__tmp, __s);
> this->_M_initialize_numpunct(__tmp);
> this->_S_destroy_c_locale(__tmp);
> }
> }
>
> protected:
> virtual
> ~numpunct_byname() { }
> };
>
>
># 1914 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> template<typename _CharT, typename _InIter>
> class num_get : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _InIter iter_type;
>
>
>
> static locale::id id;
># 1935 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> explicit
> num_get(size_t __refs = 0) : facet(__refs) { }
># 1961 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, bool& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
># 1998 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned short& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned int& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned long& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long long& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned long long& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
># 2058 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, float& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, double& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long double& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
># 2101 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, void*& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> protected:
>
> virtual ~num_get() { }
>
> iter_type
> _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
> string&) const;
>
> template<typename _ValueT>
> iter_type
> _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
> _ValueT&) const;
>
> template<typename _CharT2>
> typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
> _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
> {
> int __ret = -1;
> if (__len <= 10)
> {
> if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
> __ret = __c - _CharT2('0');
> }
> else
> {
> if (__c >= _CharT2('0') && __c <= _CharT2('9'))
> __ret = __c - _CharT2('0');
> else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
> __ret = 10 + (__c - _CharT2('a'));
> else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
> __ret = 10 + (__c - _CharT2('A'));
> }
> return __ret;
> }
>
> template<typename _CharT2>
> typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
> int>::__type
> _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
> {
> int __ret = -1;
> const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
> if (__q)
> {
> __ret = __q - __zero;
> if (__ret > 15)
> __ret -= 6;
> }
> return __ret;
> }
># 2172 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
>
> virtual iter_type
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> virtual iter_type
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned short& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> virtual iter_type
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned int& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> virtual iter_type
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
>
> virtual iter_type
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> virtual iter_type
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned long long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
> double&) const;
>
>
>
>
>
>
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
> long double&) const;
>
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
># 2235 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> };
>
> template<typename _CharT, typename _InIter>
> locale::id num_get<_CharT, _InIter>::id;
># 2253 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> template<typename _CharT, typename _OutIter>
> class num_put : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _OutIter iter_type;
>
>
>
> static locale::id id;
># 2274 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> explicit
> num_put(size_t __refs = 0) : facet(__refs) { }
># 2292 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
> { return this->do_put(__s, __io, __fill, __v); }
># 2334 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
> { return this->do_put(__s, __io, __fill, __v); }
>
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill,
> unsigned long __v) const
> { return this->do_put(__s, __io, __fill, __v); }
>
>
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
> { return this->do_put(__s, __io, __fill, __v); }
>
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill,
> unsigned long long __v) const
> { return this->do_put(__s, __io, __fill, __v); }
># 2397 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
> { return this->do_put(__s, __io, __fill, __v); }
>
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill,
> long double __v) const
> { return this->do_put(__s, __io, __fill, __v); }
># 2422 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill,
> const void* __v) const
> { return this->do_put(__s, __io, __fill, __v); }
>
> protected:
> template<typename _ValueT>
> iter_type
> _M_insert_float(iter_type, ios_base& __io, char_type __fill,
> char __mod, _ValueT __v) const;
>
> void
> _M_group_float(const char* __grouping, size_t __grouping_size,
> char_type __sep, const char_type* __p, char_type* __new,
> char_type* __cs, int& __len) const;
>
> template<typename _ValueT>
> iter_type
> _M_insert_int(iter_type, ios_base& __io, char_type __fill,
> _ValueT __v) const;
>
> void
> _M_group_int(const char* __grouping, size_t __grouping_size,
> char_type __sep, ios_base& __io, char_type* __new,
> char_type* __cs, int& __len) const;
>
> void
> _M_pad(char_type __fill, streamsize __w, ios_base& __io,
> char_type* __new, const char_type* __cs, int& __len) const;
>
>
> virtual
> ~num_put() { };
># 2470 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
>
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> unsigned long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
>
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> long long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> unsigned long long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type, double) const;
>
>
>
>
>
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type, long double) const;
>
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type, const void*) const;
>
>
>
>
>
>
>
> };
>
> template <typename _CharT, typename _OutIter>
> locale::id num_put<_CharT, _OutIter>::id;
>
>
>
>
>
>
>
>
>
> template<typename _CharT>
> inline bool
> isspace(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
>
>
> template<typename _CharT>
> inline bool
> isprint(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
>
>
> template<typename _CharT>
> inline bool
> iscntrl(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
>
>
> template<typename _CharT>
> inline bool
> isupper(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
>
>
> template<typename _CharT>
> inline bool
> islower(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
>
>
> template<typename _CharT>
> inline bool
> isalpha(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
>
>
> template<typename _CharT>
> inline bool
> isdigit(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
>
>
> template<typename _CharT>
> inline bool
> ispunct(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
>
>
> template<typename _CharT>
> inline bool
> isxdigit(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
>
>
> template<typename _CharT>
> inline bool
> isalnum(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
>
>
> template<typename _CharT>
> inline bool
> isgraph(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
>
>
> template<typename _CharT>
> inline _CharT
> toupper(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
>
>
> template<typename _CharT>
> inline _CharT
> tolower(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
>
>
>}
>
># 1 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 1 3
># 33 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
> 
># 34 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
> template<typename _Facet>
> struct __use_cache
> {
> const _Facet*
> operator() (const locale& __loc) const;
> };
>
>
> template<typename _CharT>
> struct __use_cache<__numpunct_cache<_CharT> >
> {
> const __numpunct_cache<_CharT>*
> operator() (const locale& __loc) const
> {
> const size_t __i = numpunct<_CharT>::id._M_id();
> const locale::facet** __caches = __loc._M_impl->_M_caches;
> if (!__caches[__i])
> {
> __numpunct_cache<_CharT>* __tmp = 0;
> try
> {
> __tmp = new __numpunct_cache<_CharT>;
> __tmp->_M_cache(__loc);
> }
> catch(...)
> {
> delete __tmp;
> throw;
> }
> __loc._M_impl->_M_install_cache(__tmp, __i);
> }
> return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
> }
> };
>
> template<typename _CharT>
> void
> __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
> {
> _M_allocated = true;
>
> const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
>
> char* __grouping = 0;
> _CharT* __truename = 0;
> _CharT* __falsename = 0;
> try
> {
> _M_grouping_size = __np.grouping().size();
> __grouping = new char[_M_grouping_size];
> __np.grouping().copy(__grouping, _M_grouping_size);
> _M_grouping = __grouping;
> _M_use_grouping = (_M_grouping_size
> && static_cast<signed char>(_M_grouping[0]) > 0
> && (_M_grouping[0]
> != __gnu_cxx::__numeric_traits<char>::__max));
>
> _M_truename_size = __np.truename().size();
> __truename = new _CharT[_M_truename_size];
> __np.truename().copy(__truename, _M_truename_size);
> _M_truename = __truename;
>
> _M_falsename_size = __np.falsename().size();
> __falsename = new _CharT[_M_falsename_size];
> __np.falsename().copy(__falsename, _M_falsename_size);
> _M_falsename = __falsename;
>
> _M_decimal_point = __np.decimal_point();
> _M_thousands_sep = __np.thousands_sep();
>
> const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
> __ct.widen(__num_base::_S_atoms_out,
> __num_base::_S_atoms_out
> + __num_base::_S_oend, _M_atoms_out);
> __ct.widen(__num_base::_S_atoms_in,
> __num_base::_S_atoms_in
> + __num_base::_S_iend, _M_atoms_in);
> }
> catch(...)
> {
> delete [] __grouping;
> delete [] __truename;
> delete [] __falsename;
> throw;
> }
> }
># 136 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
> __attribute__ ((__pure__)) bool
> __verify_grouping(const char* __grouping, size_t __grouping_size,
> const string& __grouping_tmp) throw ();
>
>
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
> ios_base::iostate& __err, string& __xtrc) const
> {
> typedef char_traits<_CharT> __traits_type;
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
> const _CharT* __lit = __lc->_M_atoms_in;
> char_type __c = char_type();
>
>
> bool __testeof = __beg == __end;
>
>
> if (!__testeof)
> {
> __c = *__beg;
> const bool __plus = __c == __lit[__num_base::_S_iplus];
> if ((__plus || __c == __lit[__num_base::_S_iminus])
> && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> && !(__c == __lc->_M_decimal_point))
> {
> __xtrc += __plus ? '+' : '-';
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
> }
>
>
> bool __found_mantissa = false;
> int __sep_pos = 0;
> while (!__testeof)
> {
> if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> || __c == __lc->_M_decimal_point)
> break;
> else if (__c == __lit[__num_base::_S_izero])
> {
> if (!__found_mantissa)
> {
> __xtrc += '0';
> __found_mantissa = true;
> }
> ++__sep_pos;
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
> else
> break;
> }
>
>
> bool __found_dec = false;
> bool __found_sci = false;
> string __found_grouping;
> if (__lc->_M_use_grouping)
> __found_grouping.reserve(32);
> const char_type* __lit_zero = __lit + __num_base::_S_izero;
>
> if (!__lc->_M_allocated)
>
> while (!__testeof)
> {
> const int __digit = _M_find(__lit_zero, 10, __c);
> if (__digit != -1)
> {
> __xtrc += '0' + __digit;
> __found_mantissa = true;
> }
> else if (__c == __lc->_M_decimal_point
> && !__found_dec && !__found_sci)
> {
> __xtrc += '.';
> __found_dec = true;
> }
> else if ((__c == __lit[__num_base::_S_ie]
> || __c == __lit[__num_base::_S_iE])
> && !__found_sci && __found_mantissa)
> {
>
> __xtrc += 'e';
> __found_sci = true;
>
>
> if (++__beg != __end)
> {
> __c = *__beg;
> const bool __plus = __c == __lit[__num_base::_S_iplus];
> if (__plus || __c == __lit[__num_base::_S_iminus])
> __xtrc += __plus ? '+' : '-';
> else
> continue;
> }
> else
> {
> __testeof = true;
> break;
> }
> }
> else
> break;
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
> else
> while (!__testeof)
> {
>
>
> if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> {
> if (!__found_dec && !__found_sci)
> {
>
>
> if (__sep_pos)
> {
> __found_grouping += static_cast<char>(__sep_pos);
> __sep_pos = 0;
> }
> else
> {
>
>
> __xtrc.clear();
> break;
> }
> }
> else
> break;
> }
> else if (__c == __lc->_M_decimal_point)
> {
> if (!__found_dec && !__found_sci)
> {
>
>
>
> if (__found_grouping.size())
> __found_grouping += static_cast<char>(__sep_pos);
> __xtrc += '.';
> __found_dec = true;
> }
> else
> break;
> }
> else
> {
> const char_type* __q =
> __traits_type::find(__lit_zero, 10, __c);
> if (__q)
> {
> __xtrc += '0' + (__q - __lit_zero);
> __found_mantissa = true;
> ++__sep_pos;
> }
> else if ((__c == __lit[__num_base::_S_ie]
> || __c == __lit[__num_base::_S_iE])
> && !__found_sci && __found_mantissa)
> {
>
> if (__found_grouping.size() && !__found_dec)
> __found_grouping += static_cast<char>(__sep_pos);
> __xtrc += 'e';
> __found_sci = true;
>
>
> if (++__beg != __end)
> {
> __c = *__beg;
> const bool __plus = __c == __lit[__num_base::_S_iplus];
> if ((__plus || __c == __lit[__num_base::_S_iminus])
> && !(__lc->_M_use_grouping
> && __c == __lc->_M_thousands_sep)
> && !(__c == __lc->_M_decimal_point))
> __xtrc += __plus ? '+' : '-';
> else
> continue;
> }
> else
> {
> __testeof = true;
> break;
> }
> }
> else
> break;
> }
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
>
>
>
> if (__found_grouping.size())
> {
>
> if (!__found_dec && !__found_sci)
> __found_grouping += static_cast<char>(__sep_pos);
>
> if (!std::__verify_grouping(__lc->_M_grouping,
> __lc->_M_grouping_size,
> __found_grouping))
> __err = ios_base::failbit;
> }
>
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> template<typename _ValueT>
> _InIter
> num_get<_CharT, _InIter>::
> _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
> ios_base::iostate& __err, _ValueT& __v) const
> {
> typedef char_traits<_CharT> __traits_type;
> using __gnu_cxx::__add_unsigned;
> typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
> const _CharT* __lit = __lc->_M_atoms_in;
> char_type __c = char_type();
>
>
> const ios_base::fmtflags __basefield = __io.flags()
> & ios_base::basefield;
> const bool __oct = __basefield == ios_base::oct;
> int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
>
>
> bool __testeof = __beg == __end;
>
>
> bool __negative = false;
> if (!__testeof)
> {
> __c = *__beg;
> __negative = __c == __lit[__num_base::_S_iminus];
> if ((__negative || __c == __lit[__num_base::_S_iplus])
> && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> && !(__c == __lc->_M_decimal_point))
> {
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
> }
>
>
>
> bool __found_zero = false;
> int __sep_pos = 0;
> while (!__testeof)
> {
> if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> || __c == __lc->_M_decimal_point)
> break;
> else if (__c == __lit[__num_base::_S_izero]
> && (!__found_zero || __base == 10))
> {
> __found_zero = true;
> ++__sep_pos;
> if (__basefield == 0)
> __base = 8;
> if (__base == 8)
> __sep_pos = 0;
> }
> else if (__found_zero
> && (__c == __lit[__num_base::_S_ix]
> || __c == __lit[__num_base::_S_iX]))
> {
> if (__basefield == 0)
> __base = 16;
> if (__base == 16)
> {
> __found_zero = false;
> __sep_pos = 0;
> }
> else
> break;
> }
> else
> break;
>
> if (++__beg != __end)
> {
> __c = *__beg;
> if (!__found_zero)
> break;
> }
> else
> __testeof = true;
> }
>
>
>
> const size_t __len = (__base == 16 ? __num_base::_S_iend
> - __num_base::_S_izero : __base);
>
>
> string __found_grouping;
> if (__lc->_M_use_grouping)
> __found_grouping.reserve(32);
> bool __testfail = false;
> bool __testoverflow = false;
> const __unsigned_type __max =
> (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
> ? -__gnu_cxx::__numeric_traits<_ValueT>::__min
> : __gnu_cxx::__numeric_traits<_ValueT>::__max;
> const __unsigned_type __smax = __max / __base;
> __unsigned_type __result = 0;
> int __digit = 0;
> const char_type* __lit_zero = __lit + __num_base::_S_izero;
>
> if (!__lc->_M_allocated)
>
> while (!__testeof)
> {
> __digit = _M_find(__lit_zero, __len, __c);
> if (__digit == -1)
> break;
>
> if (__result > __smax)
> __testoverflow = true;
> else
> {
> __result *= __base;
> __testoverflow |= __result > __max - __digit;
> __result += __digit;
> ++__sep_pos;
> }
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
> else
> while (!__testeof)
> {
>
>
> if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> {
>
>
> if (__sep_pos)
> {
> __found_grouping += static_cast<char>(__sep_pos);
> __sep_pos = 0;
> }
> else
> {
> __testfail = true;
> break;
> }
> }
> else if (__c == __lc->_M_decimal_point)
> break;
> else
> {
> const char_type* __q =
> __traits_type::find(__lit_zero, __len, __c);
> if (!__q)
> break;
>
> __digit = __q - __lit_zero;
> if (__digit > 15)
> __digit -= 6;
> if (__result > __smax)
> __testoverflow = true;
> else
> {
> __result *= __base;
> __testoverflow |= __result > __max - __digit;
> __result += __digit;
> ++__sep_pos;
> }
> }
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
>
>
>
> if (__found_grouping.size())
> {
>
> __found_grouping += static_cast<char>(__sep_pos);
>
> if (!std::__verify_grouping(__lc->_M_grouping,
> __lc->_M_grouping_size,
> __found_grouping))
> __err = ios_base::failbit;
> }
>
>
>
> if ((!__sep_pos && !__found_zero && !__found_grouping.size())
> || __testfail)
> {
> __v = 0;
> __err = ios_base::failbit;
> }
> else if (__testoverflow)
> {
> if (__negative
> && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
> __v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
> else
> __v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
> __err = ios_base::failbit;
> }
> else
> __v = __negative ? -__result : __result;
>
> if (__testeof)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
>
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, bool& __v) const
> {
> if (!(__io.flags() & ios_base::boolalpha))
> {
>
>
>
> long __l = -1;
> __beg = _M_extract_int(__beg, __end, __io, __err, __l);
> if (__l == 0 || __l == 1)
> __v = bool(__l);
> else
> {
>
>
> __v = true;
> __err = ios_base::failbit;
> if (__beg == __end)
> __err |= ios_base::eofbit;
> }
> }
> else
> {
>
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
>
> bool __testf = true;
> bool __testt = true;
> bool __donef = __lc->_M_falsename_size == 0;
> bool __donet = __lc->_M_truename_size == 0;
> bool __testeof = false;
> size_t __n = 0;
> while (!__donef || !__donet)
> {
> if (__beg == __end)
> {
> __testeof = true;
> break;
> }
>
> const char_type __c = *__beg;
>
> if (!__donef)
> __testf = __c == __lc->_M_falsename[__n];
>
> if (!__testf && __donet)
> break;
>
> if (!__donet)
> __testt = __c == __lc->_M_truename[__n];
>
> if (!__testt && __donef)
> break;
>
> if (!__testt && !__testf)
> break;
>
> ++__n;
> ++__beg;
>
> __donef = !__testf || __n >= __lc->_M_falsename_size;
> __donet = !__testt || __n >= __lc->_M_truename_size;
> }
> if (__testf && __n == __lc->_M_falsename_size && __n)
> {
> __v = false;
> if (__testt && __n == __lc->_M_truename_size)
> __err = ios_base::failbit;
> else
> __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
> }
> else if (__testt && __n == __lc->_M_truename_size && __n)
> {
> __v = true;
> __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
> }
> else
> {
>
>
> __v = false;
> __err = ios_base::failbit;
> if (__testeof)
> __err |= ios_base::eofbit;
> }
> }
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, float& __v) const
> {
> string __xtrc;
> __xtrc.reserve(32);
> __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
> std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, double& __v) const
> {
> string __xtrc;
> __xtrc.reserve(32);
> __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
> std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
># 730 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long double& __v) const
> {
> string __xtrc;
> __xtrc.reserve(32);
> __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
> std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, void*& __v) const
> {
>
> typedef ios_base::fmtflags fmtflags;
> const fmtflags __fmt = __io.flags();
> __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
>
> typedef __gnu_cxx::__conditional_type<(sizeof(void*)
> <= sizeof(unsigned long)),
> unsigned long, unsigned long long>::__type _UIntPtrType;
>
> _UIntPtrType __ul;
> __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
>
>
> __io.flags(__fmt);
>
> __v = reinterpret_cast<void*>(__ul);
> return __beg;
> }
>
>
>
> template<typename _CharT, typename _OutIter>
> void
> num_put<_CharT, _OutIter>::
> _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
> _CharT* __new, const _CharT* __cs, int& __len) const
> {
>
>
> __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
> __cs, __w, __len);
> __len = static_cast<int>(__w);
> }
>
>
>
> template<typename _CharT, typename _ValueT>
> int
> __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
> ios_base::fmtflags __flags, bool __dec)
> {
> _CharT* __buf = __bufend;
> if (__builtin_expect(__dec, true))
> {
>
> do
> {
> *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
> __v /= 10;
> }
> while (__v != 0);
> }
> else if ((__flags & ios_base::basefield) == ios_base::oct)
> {
>
> do
> {
> *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
> __v >>= 3;
> }
> while (__v != 0);
> }
> else
> {
>
> const bool __uppercase = __flags & ios_base::uppercase;
> const int __case_offset = __uppercase ? __num_base::_S_oudigits
> : __num_base::_S_odigits;
> do
> {
> *--__buf = __lit[(__v & 0xf) + __case_offset];
> __v >>= 4;
> }
> while (__v != 0);
> }
> return __bufend - __buf;
> }
>
>
>
> template<typename _CharT, typename _OutIter>
> void
> num_put<_CharT, _OutIter>::
> _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
> ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
> {
> _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
> __grouping_size, __cs, __cs + __len);
> __len = __p - __new;
> }
>
> template<typename _CharT, typename _OutIter>
> template<typename _ValueT>
> _OutIter
> num_put<_CharT, _OutIter>::
> _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
> _ValueT __v) const
> {
> using __gnu_cxx::__add_unsigned;
> typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
> const _CharT* __lit = __lc->_M_atoms_out;
> const ios_base::fmtflags __flags = __io.flags();
>
>
> const int __ilen = 5 * sizeof(_ValueT);
> _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __ilen));
>
>
>
> const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
> const bool __dec = (__basefield != ios_base::oct
> && __basefield != ios_base::hex);
> const __unsigned_type __u = ((__v > 0 || !__dec)
> ? __unsigned_type(__v)
> : -__unsigned_type(__v));
> int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
> __cs += __ilen - __len;
>
>
> if (__lc->_M_use_grouping)
> {
>
>
> _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * (__len + 1)
> * 2));
> _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
> __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
> __cs = __cs2 + 2;
> }
>
>
> if (__builtin_expect(__dec, true))
> {
>
> if (__v >= 0)
> {
> if (bool(__flags & ios_base::showpos)
> && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
> *--__cs = __lit[__num_base::_S_oplus], ++__len;
> }
> else
> *--__cs = __lit[__num_base::_S_ominus], ++__len;
> }
> else if (bool(__flags & ios_base::showbase) && __v)
> {
> if (__basefield == ios_base::oct)
> *--__cs = __lit[__num_base::_S_odigits], ++__len;
> else
> {
>
> const bool __uppercase = __flags & ios_base::uppercase;
> *--__cs = __lit[__num_base::_S_ox + __uppercase];
>
> *--__cs = __lit[__num_base::_S_odigits];
> __len += 2;
> }
> }
>
>
> const streamsize __w = __io.width();
> if (__w > static_cast<streamsize>(__len))
> {
> _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w));
> _M_pad(__fill, __w, __io, __cs3, __cs, __len);
> __cs = __cs3;
> }
> __io.width(0);
>
>
>
> return std::__write(__s, __cs, __len);
> }
>
> template<typename _CharT, typename _OutIter>
> void
> num_put<_CharT, _OutIter>::
> _M_group_float(const char* __grouping, size_t __grouping_size,
> _CharT __sep, const _CharT* __p, _CharT* __new,
> _CharT* __cs, int& __len) const
> {
>
>
>
> const int __declen = __p ? __p - __cs : __len;
> _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
> __grouping_size,
> __cs, __cs + __declen);
>
>
> int __newlen = __p2 - __new;
> if (__p)
> {
> char_traits<_CharT>::copy(__p2, __p, __len - __declen);
> __newlen += __len - __declen;
> }
> __len = __newlen;
> }
># 966 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _OutIter>
> template<typename _ValueT>
> _OutIter
> num_put<_CharT, _OutIter>::
> _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
> _ValueT __v) const
> {
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
>
>
> const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
>
> const int __max_digits =
> __gnu_cxx::__numeric_traits<_ValueT>::__digits10;
>
>
> int __len;
>
> char __fbuf[16];
> __num_base::_S_format_float(__io, __fbuf, __mod);
>
>
>
>
> int __cs_size = __max_digits * 3;
> char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
> __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
> __fbuf, __prec, __v);
>
>
> if (__len >= __cs_size)
> {
> __cs_size = __len + 1;
> __cs = static_cast<char*>(__builtin_alloca(__cs_size));
> __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
> __fbuf, __prec, __v);
> }
># 1027 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __len));
> __ctype.widen(__cs, __cs + __len, __ws);
>
>
> _CharT* __wp = 0;
> const char* __p = char_traits<char>::find(__cs, __len, '.');
> if (__p)
> {
> __wp = __ws + (__p - __cs);
> *__wp = __lc->_M_decimal_point;
> }
>
>
>
>
> if (__lc->_M_use_grouping
> && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
> && __cs[1] >= '0' && __cs[2] >= '0')))
> {
>
>
> _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __len * 2));
>
> streamsize __off = 0;
> if (__cs[0] == '-' || __cs[0] == '+')
> {
> __off = 1;
> __ws2[0] = __ws[0];
> __len -= 1;
> }
>
> _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
> __lc->_M_thousands_sep, __wp, __ws2 + __off,
> __ws + __off, __len);
> __len += __off;
>
> __ws = __ws2;
> }
>
>
> const streamsize __w = __io.width();
> if (__w > static_cast<streamsize>(__len))
> {
> _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w));
> _M_pad(__fill, __w, __io, __ws3, __ws, __len);
> __ws = __ws3;
> }
> __io.width(0);
>
>
>
> return std::__write(__s, __ws, __len);
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
> {
> const ios_base::fmtflags __flags = __io.flags();
> if ((__flags & ios_base::boolalpha) == 0)
> {
> const long __l = __v;
> __s = _M_insert_int(__s, __io, __fill, __l);
> }
> else
> {
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
>
> const _CharT* __name = __v ? __lc->_M_truename
> : __lc->_M_falsename;
> int __len = __v ? __lc->_M_truename_size
> : __lc->_M_falsename_size;
>
> const streamsize __w = __io.width();
> if (__w > static_cast<streamsize>(__len))
> {
> const streamsize __plen = __w - __len;
> _CharT* __ps
> = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __plen));
>
> char_traits<_CharT>::assign(__ps, __plen, __fill);
> __io.width(0);
>
> if ((__flags & ios_base::adjustfield) == ios_base::left)
> {
> __s = std::__write(__s, __name, __len);
> __s = std::__write(__s, __ps, __plen);
> }
> else
> {
> __s = std::__write(__s, __ps, __plen);
> __s = std::__write(__s, __name, __len);
> }
> return __s;
> }
> __io.width(0);
> __s = std::__write(__s, __name, __len);
> }
> return __s;
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
> { return _M_insert_float(__s, __io, __fill, char(), __v); }
># 1152 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> long double __v) const
> { return _M_insert_float(__s, __io, __fill, 'L', __v); }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> const void* __v) const
> {
> const ios_base::fmtflags __flags = __io.flags();
> const ios_base::fmtflags __fmt = ~(ios_base::basefield
> | ios_base::uppercase);
> __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
>
> typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
> <= sizeof(unsigned long)),
> unsigned long, unsigned long long>::__type _UIntPtrType;
>
> __s = _M_insert_int(__s, __io, __fill,
> reinterpret_cast<_UIntPtrType>(__v));
> __io.flags(__flags);
> return __s;
> }
>
>
># 1189 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _Traits>
> void
> __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
> _CharT* __news, const _CharT* __olds,
> streamsize __newlen, streamsize __oldlen)
> {
> const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
> const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
>
>
> if (__adjust == ios_base::left)
> {
> _Traits::copy(__news, __olds, __oldlen);
> _Traits::assign(__news + __oldlen, __plen, __fill);
> return;
> }
>
> size_t __mod = 0;
> if (__adjust == ios_base::internal)
> {
>
>
>
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> if (__ctype.widen('-') == __olds[0]
> || __ctype.widen('+') == __olds[0])
> {
> __news[0] = __olds[0];
> __mod = 1;
> ++__news;
> }
> else if (__ctype.widen('0') == __olds[0]
> && __oldlen > 1
> && (__ctype.widen('x') == __olds[1]
> || __ctype.widen('X') == __olds[1]))
> {
> __news[0] = __olds[0];
> __news[1] = __olds[1];
> __mod = 2;
> __news += 2;
> }
>
> }
> _Traits::assign(__news, __plen, __fill);
> _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
> }
>
> template<typename _CharT>
> _CharT*
> __add_grouping(_CharT* __s, _CharT __sep,
> const char* __gbeg, size_t __gsize,
> const _CharT* __first, const _CharT* __last)
> {
> size_t __idx = 0;
> size_t __ctr = 0;
>
> while (__last - __first > __gbeg[__idx]
> && static_cast<signed char>(__gbeg[__idx]) > 0
> && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
> {
> __last -= __gbeg[__idx];
> __idx < __gsize - 1 ? ++__idx : ++__ctr;
> }
>
> while (__first != __last)
> *__s++ = *__first++;
>
> while (__ctr--)
> {
> *__s++ = __sep;
> for (char __i = __gbeg[__idx]; __i > 0; --__i)
> *__s++ = *__first++;
> }
>
> while (__idx--)
> {
> *__s++ = __sep;
> for (char __i = __gbeg[__idx]; __i > 0; --__i)
> *__s++ = *__first++;
> }
>
> return __s;
> }
>
>
>
>
> extern template class numpunct<char>;
> extern template class numpunct_byname<char>;
> extern template class num_get<char>;
> extern template class num_put<char>;
> extern template class ctype_byname<char>;
>
> extern template
> const ctype<char>&
> use_facet<ctype<char> >(const locale&);
>
> extern template
> const numpunct<char>&
> use_facet<numpunct<char> >(const locale&);
>
> extern template
> const num_put<char>&
> use_facet<num_put<char> >(const locale&);
>
> extern template
> const num_get<char>&
> use_facet<num_get<char> >(const locale&);
>
> extern template
> bool
> has_facet<ctype<char> >(const locale&);
>
> extern template
> bool
> has_facet<numpunct<char> >(const locale&);
>
> extern template
> bool
> has_facet<num_put<char> >(const locale&);
>
> extern template
> bool
> has_facet<num_get<char> >(const locale&);
>
>
> extern template class numpunct<wchar_t>;
> extern template class numpunct_byname<wchar_t>;
> extern template class num_get<wchar_t>;
> extern template class num_put<wchar_t>;
> extern template class ctype_byname<wchar_t>;
>
> extern template
> const ctype<wchar_t>&
> use_facet<ctype<wchar_t> >(const locale&);
>
> extern template
> const numpunct<wchar_t>&
> use_facet<numpunct<wchar_t> >(const locale&);
>
> extern template
> const num_put<wchar_t>&
> use_facet<num_put<wchar_t> >(const locale&);
>
> extern template
> const num_get<wchar_t>&
> use_facet<num_get<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<ctype<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<numpunct<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<num_put<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<num_get<wchar_t> >(const locale&);
>
>
>
>
>}
># 2609 "/usr/include/c++/4.8.2/bits/locale_facets.h" 2 3
># 38 "/usr/include/c++/4.8.2/bits/basic_ios.h" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Facet>
> inline const _Facet&
> __check_facet(const _Facet* __f)
> {
> if (!__f)
> __throw_bad_cast();
> return *__f;
> }
># 65 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
> template<typename _CharT, typename _Traits>
> class basic_ios : public ios_base
> {
> public:
>
>
>
>
>
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
>
>
>
>
>
>
> typedef ctype<_CharT> __ctype_type;
> typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
> __num_put_type;
> typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
> __num_get_type;
>
>
>
> protected:
> basic_ostream<_CharT, _Traits>* _M_tie;
> mutable char_type _M_fill;
> mutable bool _M_fill_init;
> basic_streambuf<_CharT, _Traits>* _M_streambuf;
>
>
> const __ctype_type* _M_ctype;
>
> const __num_put_type* _M_num_put;
>
> const __num_get_type* _M_num_get;
>
> public:
>
>
>
>
>
>
>
> operator void*() const
> { return this->fail() ? 0 : const_cast<basic_ios*>(this); }
>
> bool
> operator!() const
> { return this->fail(); }
># 130 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
> iostate
> rdstate() const
> { return _M_streambuf_state; }
># 141 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
> void
> clear(iostate __state = goodbit);
>
>
>
>
>
>
>
> void
> setstate(iostate __state)
> { this->clear(this->rdstate() | __state); }
>
>
>
>
> void
> _M_setstate(iostate __state)
> {
>
>
> _M_streambuf_state |= __state;
> if (this->exceptions() & __state)
> throw;
> }
>
>
>
>
>
>
>
> bool
> good() const
> { return this->rdstate() == 0; }
>
>
>
>
>
>
>
> bool
> eof() const
> { return (this->rdstate() & eofbit) != 0; }
># 194 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
> bool
> fail() const
> { return (this->rdstate() & (badbit | failbit)) != 0; }
>
>
>
>
>
>
>
> bool
> bad() const
> { return (this->rdstate() & badbit) != 0; }
># 215 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
> iostate
> exceptions() const
> { return _M_exception; }
># 250 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
> void
> exceptions(iostate __except)
> {
> _M_exception = __except;
> this->clear(_M_streambuf_state);
> }
>
>
>
>
>
>
>
> explicit
> basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
> : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
> _M_ctype(0), _M_num_put(0), _M_num_get(0)
> { this->init(__sb); }
>
>
>
>
>
>
>
> virtual
> ~basic_ios() { }
># 288 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
> basic_ostream<_CharT, _Traits>*
> tie() const
> { return _M_tie; }
># 300 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
> basic_ostream<_CharT, _Traits>*
> tie(basic_ostream<_CharT, _Traits>* __tiestr)
> {
> basic_ostream<_CharT, _Traits>* __old = _M_tie;
> _M_tie = __tiestr;
> return __old;
> }
>
>
>
>
>
>
>
> basic_streambuf<_CharT, _Traits>*
> rdbuf() const
> { return _M_streambuf; }
># 340 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
> basic_streambuf<_CharT, _Traits>*
> rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
># 354 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
> basic_ios&
> copyfmt(const basic_ios& __rhs);
>
>
>
>
>
>
>
> char_type
> fill() const
> {
> if (!_M_fill_init)
> {
> _M_fill = this->widen(' ');
> _M_fill_init = true;
> }
> return _M_fill;
> }
># 383 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
> char_type
> fill(char_type __ch)
> {
> char_type __old = this->fill();
> _M_fill = __ch;
> return __old;
> }
># 403 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
> locale
> imbue(const locale& __loc);
># 423 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
> char
> narrow(char_type __c, char __dfault) const
> { return __check_facet(_M_ctype).narrow(__c, __dfault); }
># 442 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
> char_type
> widen(char __c) const
> { return __check_facet(_M_ctype).widen(__c); }
>
> protected:
>
>
>
>
>
>
>
> basic_ios()
> : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
> _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
> { }
>
>
>
>
>
>
>
> void
> init(basic_streambuf<_CharT, _Traits>* __sb);
>
> void
> _M_cache_locale(const locale& __loc);
> };
>
>
>}
>
># 1 "/usr/include/c++/4.8.2/bits/basic_ios.tcc" 1 3
># 33 "/usr/include/c++/4.8.2/bits/basic_ios.tcc" 3
> 
># 34 "/usr/include/c++/4.8.2/bits/basic_ios.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> void
> basic_ios<_CharT, _Traits>::clear(iostate __state)
> {
> if (this->rdbuf())
> _M_streambuf_state = __state;
> else
> _M_streambuf_state = __state | badbit;
> if (this->exceptions() & this->rdstate())
> __throw_ios_failure(("basic_ios::clear"));
> }
>
> template<typename _CharT, typename _Traits>
> basic_streambuf<_CharT, _Traits>*
> basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
> {
> basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
> _M_streambuf = __sb;
> this->clear();
> return __old;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ios<_CharT, _Traits>&
> basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
> {
>
>
> if (this != &__rhs)
> {
>
>
>
>
> _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
> _M_local_word : new _Words[__rhs._M_word_size];
>
>
> _Callback_list* __cb = __rhs._M_callbacks;
> if (__cb)
> __cb->_M_add_reference();
> _M_call_callbacks(erase_event);
> if (_M_word != _M_local_word)
> {
> delete [] _M_word;
> _M_word = 0;
> }
> _M_dispose_callbacks();
>
>
> _M_callbacks = __cb;
> for (int __i = 0; __i < __rhs._M_word_size; ++__i)
> __words[__i] = __rhs._M_word[__i];
> _M_word = __words;
> _M_word_size = __rhs._M_word_size;
>
> this->flags(__rhs.flags());
> this->width(__rhs.width());
> this->precision(__rhs.precision());
> this->tie(__rhs.tie());
> this->fill(__rhs.fill());
> _M_ios_locale = __rhs.getloc();
> _M_cache_locale(_M_ios_locale);
>
> _M_call_callbacks(copyfmt_event);
>
>
> this->exceptions(__rhs.exceptions());
> }
> return *this;
> }
>
>
> template<typename _CharT, typename _Traits>
> locale
> basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
> {
> locale __old(this->getloc());
> ios_base::imbue(__loc);
> _M_cache_locale(__loc);
> if (this->rdbuf() != 0)
> this->rdbuf()->pubimbue(__loc);
> return __old;
> }
>
> template<typename _CharT, typename _Traits>
> void
> basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
> {
>
> ios_base::_M_init();
>
>
> _M_cache_locale(_M_ios_locale);
># 146 "/usr/include/c++/4.8.2/bits/basic_ios.tcc" 3
> _M_fill = _CharT();
> _M_fill_init = false;
>
> _M_tie = 0;
> _M_exception = goodbit;
> _M_streambuf = __sb;
> _M_streambuf_state = __sb ? goodbit : badbit;
> }
>
> template<typename _CharT, typename _Traits>
> void
> basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
> {
> if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
> _M_ctype = &use_facet<__ctype_type>(__loc);
> else
> _M_ctype = 0;
>
> if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
> _M_num_put = &use_facet<__num_put_type>(__loc);
> else
> _M_num_put = 0;
>
> if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
> _M_num_get = &use_facet<__num_get_type>(__loc);
> else
> _M_num_get = 0;
> }
>
>
>
>
> extern template class basic_ios<char>;
>
>
> extern template class basic_ios<wchar_t>;
>
>
>
>
>}
># 476 "/usr/include/c++/4.8.2/bits/basic_ios.h" 2 3
># 45 "/usr/include/c++/4.8.2/ios" 2 3
># 39 "/usr/include/c++/4.8.2/istream" 2 3
># 1 "/usr/include/c++/4.8.2/ostream" 1 3
># 36 "/usr/include/c++/4.8.2/ostream" 3
> 
># 37 "/usr/include/c++/4.8.2/ostream" 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 57 "/usr/include/c++/4.8.2/ostream" 3
> template<typename _CharT, typename _Traits>
> class basic_ostream : virtual public basic_ios<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
>
>
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef basic_ios<_CharT, _Traits> __ios_type;
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
> __num_put_type;
> typedef ctype<_CharT> __ctype_type;
># 83 "/usr/include/c++/4.8.2/ostream" 3
> explicit
> basic_ostream(__streambuf_type* __sb)
> { this->init(__sb); }
>
>
>
>
>
>
> virtual
> ~basic_ostream() { }
>
>
> class sentry;
> friend class sentry;
># 107 "/usr/include/c++/4.8.2/ostream" 3
> __ostream_type&
> operator<<(__ostream_type& (*__pf)(__ostream_type&))
> {
>
>
>
> return __pf(*this);
> }
>
> __ostream_type&
> operator<<(__ios_type& (*__pf)(__ios_type&))
> {
>
>
>
> __pf(*this);
> return *this;
> }
>
> __ostream_type&
> operator<<(ios_base& (*__pf) (ios_base&))
> {
>
>
>
> __pf(*this);
> return *this;
> }
># 165 "/usr/include/c++/4.8.2/ostream" 3
> __ostream_type&
> operator<<(long __n)
> { return _M_insert(__n); }
>
> __ostream_type&
> operator<<(unsigned long __n)
> { return _M_insert(__n); }
>
> __ostream_type&
> operator<<(bool __n)
> { return _M_insert(__n); }
>
> __ostream_type&
> operator<<(short __n);
>
> __ostream_type&
> operator<<(unsigned short __n)
> {
>
>
> return _M_insert(static_cast<unsigned long>(__n));
> }
>
> __ostream_type&
> operator<<(int __n);
>
> __ostream_type&
> operator<<(unsigned int __n)
> {
>
>
> return _M_insert(static_cast<unsigned long>(__n));
> }
>
>
> __ostream_type&
> operator<<(long long __n)
> { return _M_insert(__n); }
>
> __ostream_type&
> operator<<(unsigned long long __n)
> { return _M_insert(__n); }
># 219 "/usr/include/c++/4.8.2/ostream" 3
> __ostream_type&
> operator<<(double __f)
> { return _M_insert(__f); }
>
> __ostream_type&
> operator<<(float __f)
> {
>
>
> return _M_insert(static_cast<double>(__f));
> }
>
> __ostream_type&
> operator<<(long double __f)
> { return _M_insert(__f); }
># 244 "/usr/include/c++/4.8.2/ostream" 3
> __ostream_type&
> operator<<(const void* __p)
> { return _M_insert(__p); }
># 269 "/usr/include/c++/4.8.2/ostream" 3
> __ostream_type&
> operator<<(__streambuf_type* __sb);
># 302 "/usr/include/c++/4.8.2/ostream" 3
> __ostream_type&
> put(char_type __c);
>
>
>
>
>
>
> void
> _M_write(const char_type* __s, streamsize __n)
> {
> const streamsize __put = this->rdbuf()->sputn(__s, __n);
> if (__put != __n)
> this->setstate(ios_base::badbit);
> }
># 334 "/usr/include/c++/4.8.2/ostream" 3
> __ostream_type&
> write(const char_type* __s, streamsize __n);
># 347 "/usr/include/c++/4.8.2/ostream" 3
> __ostream_type&
> flush();
># 357 "/usr/include/c++/4.8.2/ostream" 3
> pos_type
> tellp();
># 368 "/usr/include/c++/4.8.2/ostream" 3
> __ostream_type&
> seekp(pos_type);
># 380 "/usr/include/c++/4.8.2/ostream" 3
> __ostream_type&
> seekp(off_type, ios_base::seekdir);
>
> protected:
> basic_ostream()
> { this->init(0); }
>
> template<typename _ValueT>
> __ostream_type&
> _M_insert(_ValueT __v);
> };
># 399 "/usr/include/c++/4.8.2/ostream" 3
> template <typename _CharT, typename _Traits>
> class basic_ostream<_CharT, _Traits>::sentry
> {
>
> bool _M_ok;
> basic_ostream<_CharT, _Traits>& _M_os;
>
> public:
># 418 "/usr/include/c++/4.8.2/ostream" 3
> explicit
> sentry(basic_ostream<_CharT, _Traits>& __os);
># 428 "/usr/include/c++/4.8.2/ostream" 3
> ~sentry()
> {
>
> if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
> {
>
> if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
> _M_os.setstate(ios_base::badbit);
> }
> }
># 447 "/usr/include/c++/4.8.2/ostream" 3
> explicit
>
> operator bool() const
> { return _M_ok; }
> };
># 469 "/usr/include/c++/4.8.2/ostream" 3
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
> { return __ostream_insert(__out, &__c, 1); }
>
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
> { return (__out << __out.widen(__c)); }
>
>
> template <class _Traits>
> inline basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, char __c)
> { return __ostream_insert(__out, &__c, 1); }
>
>
> template<class _Traits>
> inline basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
> { return (__out << static_cast<char>(__c)); }
>
> template<class _Traits>
> inline basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
> { return (__out << static_cast<char>(__c)); }
># 511 "/usr/include/c++/4.8.2/ostream" 3
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
> {
> if (!__s)
> __out.setstate(ios_base::badbit);
> else
> __ostream_insert(__out, __s,
> static_cast<streamsize>(_Traits::length(__s)));
> return __out;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits> &
> operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
>
>
> template<class _Traits>
> inline basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
> {
> if (!__s)
> __out.setstate(ios_base::badbit);
> else
> __ostream_insert(__out, __s,
> static_cast<streamsize>(_Traits::length(__s)));
> return __out;
> }
>
>
> template<class _Traits>
> inline basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
> { return (__out << reinterpret_cast<const char*>(__s)); }
>
> template<class _Traits>
> inline basic_ostream<char, _Traits> &
> operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
> { return (__out << reinterpret_cast<const char*>(__s)); }
># 562 "/usr/include/c++/4.8.2/ostream" 3
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> endl(basic_ostream<_CharT, _Traits>& __os)
> { return flush(__os.put(__os.widen('\n'))); }
># 574 "/usr/include/c++/4.8.2/ostream" 3
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> ends(basic_ostream<_CharT, _Traits>& __os)
> { return __os.put(_CharT()); }
>
>
>
>
>
>
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> flush(basic_ostream<_CharT, _Traits>& __os)
> { return __os.flush(); }
># 600 "/usr/include/c++/4.8.2/ostream" 3
> template<typename _CharT, typename _Traits, typename _Tp>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
> { return (__os << __x); }
>
>
>
>}
>
># 1 "/usr/include/c++/4.8.2/bits/ostream.tcc" 1 3
># 37 "/usr/include/c++/4.8.2/bits/ostream.tcc" 3
> 
># 38 "/usr/include/c++/4.8.2/bits/ostream.tcc" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>::sentry::
> sentry(basic_ostream<_CharT, _Traits>& __os)
> : _M_ok(false), _M_os(__os)
> {
>
> if (__os.tie() && __os.good())
> __os.tie()->flush();
>
> if (__os.good())
> _M_ok = true;
> else
> __os.setstate(ios_base::failbit);
> }
>
> template<typename _CharT, typename _Traits>
> template<typename _ValueT>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> _M_insert(_ValueT __v)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __v).failed())
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(short __n)
> {
>
>
> const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
> if (__fmt == ios_base::oct || __fmt == ios_base::hex)
> return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
> else
> return _M_insert(static_cast<long>(__n));
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(int __n)
> {
>
>
> const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
> if (__fmt == ios_base::oct || __fmt == ios_base::hex)
> return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
> else
> return _M_insert(static_cast<long>(__n));
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(__streambuf_type* __sbin)
> {
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this);
> if (__cerb && __sbin)
> {
> try
> {
> if (!__copy_streambufs(__sbin, this->rdbuf()))
> __err |= ios_base::failbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::failbit); }
> }
> else if (!__sbin)
> __err |= ios_base::badbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> put(char_type __c)
> {
>
>
>
>
>
>
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __put = this->rdbuf()->sputc(__c);
> if (traits_type::eq_int_type(__put, traits_type::eof()))
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> write(const _CharT* __s, streamsize __n)
> {
>
>
>
>
>
>
>
> sentry __cerb(*this);
> if (__cerb)
> {
> try
> { _M_write(__s, __n); }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> flush()
> {
>
>
>
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_ostream<_CharT, _Traits>::pos_type
> basic_ostream<_CharT, _Traits>::
> tellp()
> {
> pos_type __ret = pos_type(-1);
> try
> {
> if (!this->fail())
> __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> seekp(pos_type __pos)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> if (!this->fail())
> {
>
>
> const pos_type __p = this->rdbuf()->pubseekpos(__pos,
> ios_base::out);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> seekp(off_type __off, ios_base::seekdir __dir)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> if (!this->fail())
> {
>
>
> const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
> ios_base::out);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
> {
> if (!__s)
> __out.setstate(ios_base::badbit);
> else
> {
>
>
> const size_t __clen = char_traits<char>::length(__s);
> try
> {
> struct __ptr_guard
> {
> _CharT *__p;
> __ptr_guard (_CharT *__ip): __p(__ip) { }
> ~__ptr_guard() { delete[] __p; }
> _CharT* __get() { return __p; }
> } __pg (new _CharT[__clen]);
>
> _CharT *__ws = __pg.__get();
> for (size_t __i = 0; __i < __clen; ++__i)
> __ws[__i] = __out.widen(__s[__i]);
> __ostream_insert(__out, __ws, __clen);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __out._M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { __out._M_setstate(ios_base::badbit); }
> }
> return __out;
> }
>
>
>
>
> extern template class basic_ostream<char>;
> extern template ostream& endl(ostream&);
> extern template ostream& ends(ostream&);
> extern template ostream& flush(ostream&);
> extern template ostream& operator<<(ostream&, char);
> extern template ostream& operator<<(ostream&, unsigned char);
> extern template ostream& operator<<(ostream&, signed char);
> extern template ostream& operator<<(ostream&, const char*);
> extern template ostream& operator<<(ostream&, const unsigned char*);
> extern template ostream& operator<<(ostream&, const signed char*);
>
> extern template ostream& ostream::_M_insert(long);
> extern template ostream& ostream::_M_insert(unsigned long);
> extern template ostream& ostream::_M_insert(bool);
>
> extern template ostream& ostream::_M_insert(long long);
> extern template ostream& ostream::_M_insert(unsigned long long);
>
> extern template ostream& ostream::_M_insert(double);
> extern template ostream& ostream::_M_insert(long double);
> extern template ostream& ostream::_M_insert(const void*);
>
>
> extern template class basic_ostream<wchar_t>;
> extern template wostream& endl(wostream&);
> extern template wostream& ends(wostream&);
> extern template wostream& flush(wostream&);
> extern template wostream& operator<<(wostream&, wchar_t);
> extern template wostream& operator<<(wostream&, char);
> extern template wostream& operator<<(wostream&, const wchar_t*);
> extern template wostream& operator<<(wostream&, const char*);
>
> extern template wostream& wostream::_M_insert(long);
> extern template wostream& wostream::_M_insert(unsigned long);
> extern template wostream& wostream::_M_insert(bool);
>
> extern template wostream& wostream::_M_insert(long long);
> extern template wostream& wostream::_M_insert(unsigned long long);
>
> extern template wostream& wostream::_M_insert(double);
> extern template wostream& wostream::_M_insert(long double);
> extern template wostream& wostream::_M_insert(const void*);
>
>
>
>
>}
># 610 "/usr/include/c++/4.8.2/ostream" 2 3
># 40 "/usr/include/c++/4.8.2/istream" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 57 "/usr/include/c++/4.8.2/istream" 3
> template<typename _CharT, typename _Traits>
> class basic_istream : virtual public basic_ios<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
>
>
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef basic_ios<_CharT, _Traits> __ios_type;
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
> __num_get_type;
> typedef ctype<_CharT> __ctype_type;
>
> protected:
>
>
>
>
>
> streamsize _M_gcount;
>
> public:
>
>
>
>
>
>
>
> explicit
> basic_istream(__streambuf_type* __sb)
> : _M_gcount(streamsize(0))
> { this->init(__sb); }
>
>
>
>
>
>
> virtual
> ~basic_istream()
> { _M_gcount = streamsize(0); }
>
>
> class sentry;
> friend class sentry;
># 119 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> operator>>(__istream_type& (*__pf)(__istream_type&))
> { return __pf(*this); }
>
> __istream_type&
> operator>>(__ios_type& (*__pf)(__ios_type&))
> {
> __pf(*this);
> return *this;
> }
>
> __istream_type&
> operator>>(ios_base& (*__pf)(ios_base&))
> {
> __pf(*this);
> return *this;
> }
># 167 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> operator>>(bool& __n)
> { return _M_extract(__n); }
>
> __istream_type&
> operator>>(short& __n);
>
> __istream_type&
> operator>>(unsigned short& __n)
> { return _M_extract(__n); }
>
> __istream_type&
> operator>>(int& __n);
>
> __istream_type&
> operator>>(unsigned int& __n)
> { return _M_extract(__n); }
>
> __istream_type&
> operator>>(long& __n)
> { return _M_extract(__n); }
>
> __istream_type&
> operator>>(unsigned long& __n)
> { return _M_extract(__n); }
>
>
> __istream_type&
> operator>>(long long& __n)
> { return _M_extract(__n); }
>
> __istream_type&
> operator>>(unsigned long long& __n)
> { return _M_extract(__n); }
># 213 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> operator>>(float& __f)
> { return _M_extract(__f); }
>
> __istream_type&
> operator>>(double& __f)
> { return _M_extract(__f); }
>
> __istream_type&
> operator>>(long double& __f)
> { return _M_extract(__f); }
># 234 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> operator>>(void*& __p)
> { return _M_extract(__p); }
># 258 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> operator>>(__streambuf_type* __sb);
># 268 "/usr/include/c++/4.8.2/istream" 3
> streamsize
> gcount() const
> { return _M_gcount; }
># 301 "/usr/include/c++/4.8.2/istream" 3
> int_type
> get();
># 315 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> get(char_type& __c);
># 342 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> get(char_type* __s, streamsize __n, char_type __delim);
># 353 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> get(char_type* __s, streamsize __n)
> { return this->get(__s, __n, this->widen('\n')); }
># 376 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> get(__streambuf_type& __sb, char_type __delim);
># 386 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> get(__streambuf_type& __sb)
> { return this->get(__sb, this->widen('\n')); }
># 415 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> getline(char_type* __s, streamsize __n, char_type __delim);
># 426 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> getline(char_type* __s, streamsize __n)
> { return this->getline(__s, __n, this->widen('\n')); }
># 450 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> ignore(streamsize __n, int_type __delim);
>
> __istream_type&
> ignore(streamsize __n);
>
> __istream_type&
> ignore();
># 467 "/usr/include/c++/4.8.2/istream" 3
> int_type
> peek();
># 485 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> read(char_type* __s, streamsize __n);
># 504 "/usr/include/c++/4.8.2/istream" 3
> streamsize
> readsome(char_type* __s, streamsize __n);
># 521 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> putback(char_type __c);
># 537 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> unget();
># 555 "/usr/include/c++/4.8.2/istream" 3
> int
> sync();
># 570 "/usr/include/c++/4.8.2/istream" 3
> pos_type
> tellg();
># 585 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> seekg(pos_type);
># 601 "/usr/include/c++/4.8.2/istream" 3
> __istream_type&
> seekg(off_type, ios_base::seekdir);
>
>
> protected:
> basic_istream()
> : _M_gcount(streamsize(0))
> { this->init(0); }
>
> template<typename _ValueT>
> __istream_type&
> _M_extract(_ValueT& __v);
> };
>
>
> template<>
> basic_istream<char>&
> basic_istream<char>::
> getline(char_type* __s, streamsize __n, char_type __delim);
>
> template<>
> basic_istream<char>&
> basic_istream<char>::
> ignore(streamsize __n);
>
> template<>
> basic_istream<char>&
> basic_istream<char>::
> ignore(streamsize __n, int_type __delim);
>
>
> template<>
> basic_istream<wchar_t>&
> basic_istream<wchar_t>::
> getline(char_type* __s, streamsize __n, char_type __delim);
>
> template<>
> basic_istream<wchar_t>&
> basic_istream<wchar_t>::
> ignore(streamsize __n);
>
> template<>
> basic_istream<wchar_t>&
> basic_istream<wchar_t>::
> ignore(streamsize __n, int_type __delim);
># 656 "/usr/include/c++/4.8.2/istream" 3
> template<typename _CharT, typename _Traits>
> class basic_istream<_CharT, _Traits>::sentry
> {
>
> bool _M_ok;
>
> public:
>
> typedef _Traits traits_type;
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::__ctype_type __ctype_type;
> typedef typename _Traits::int_type __int_type;
># 692 "/usr/include/c++/4.8.2/istream" 3
> explicit
> sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
># 703 "/usr/include/c++/4.8.2/istream" 3
> explicit
>
> operator bool() const
> { return _M_ok; }
> };
># 721 "/usr/include/c++/4.8.2/istream" 3
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
>
> template<class _Traits>
> inline basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
> { return (__in >> reinterpret_cast<char&>(__c)); }
>
> template<class _Traits>
> inline basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
> { return (__in >> reinterpret_cast<char&>(__c)); }
># 763 "/usr/include/c++/4.8.2/istream" 3
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
>
>
> template<>
> basic_istream<char>&
> operator>>(basic_istream<char>& __in, char* __s);
>
> template<class _Traits>
> inline basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
> { return (__in >> reinterpret_cast<char*>(__s)); }
>
> template<class _Traits>
> inline basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
> { return (__in >> reinterpret_cast<char*>(__s)); }
># 794 "/usr/include/c++/4.8.2/istream" 3
> template<typename _CharT, typename _Traits>
> class basic_iostream
> : public basic_istream<_CharT, _Traits>,
> public basic_ostream<_CharT, _Traits>
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
>
>
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
>
>
>
>
>
>
>
> explicit
> basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
> : __istream_type(__sb), __ostream_type(__sb) { }
>
>
>
>
> virtual
> ~basic_iostream() { }
>
> protected:
> basic_iostream()
> : __istream_type(), __ostream_type() { }
> };
># 854 "/usr/include/c++/4.8.2/istream" 3
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> ws(basic_istream<_CharT, _Traits>& __is);
># 870 "/usr/include/c++/4.8.2/istream" 3
> template<typename _CharT, typename _Traits, typename _Tp>
> inline basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
> { return (__is >> __x); }
>
>
>
>}
>
># 1 "/usr/include/c++/4.8.2/bits/istream.tcc" 1 3
># 37 "/usr/include/c++/4.8.2/bits/istream.tcc" 3
> 
># 38 "/usr/include/c++/4.8.2/bits/istream.tcc" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>::sentry::
> sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
> {
> ios_base::iostate __err = ios_base::goodbit;
> if (__in.good())
> {
> if (__in.tie())
> __in.tie()->flush();
> if (!__noskip && bool(__in.flags() & ios_base::skipws))
> {
> const __int_type __eof = traits_type::eof();
> __streambuf_type* __sb = __in.rdbuf();
> __int_type __c = __sb->sgetc();
>
> const __ctype_type& __ct = __check_facet(__in._M_ctype);
> while (!traits_type::eq_int_type(__c, __eof)
> && __ct.is(ctype_base::space,
> traits_type::to_char_type(__c)))
> __c = __sb->snextc();
>
>
>
>
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> }
>
> if (__in.good() && __err == ios_base::goodbit)
> _M_ok = true;
> else
> {
> __err |= ios_base::failbit;
> __in.setstate(__err);
> }
> }
>
> template<typename _CharT, typename _Traits>
> template<typename _ValueT>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> _M_extract(_ValueT& __v)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __v);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(short& __n)
> {
>
>
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> long __l;
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __l);
>
>
>
> if (__l < __gnu_cxx::__numeric_traits<short>::__min)
> {
> __err |= ios_base::failbit;
> __n = __gnu_cxx::__numeric_traits<short>::__min;
> }
> else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
> {
> __err |= ios_base::failbit;
> __n = __gnu_cxx::__numeric_traits<short>::__max;
> }
> else
> __n = short(__l);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(int& __n)
> {
>
>
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> long __l;
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __l);
>
>
>
> if (__l < __gnu_cxx::__numeric_traits<int>::__min)
> {
> __err |= ios_base::failbit;
> __n = __gnu_cxx::__numeric_traits<int>::__min;
> }
> else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
> {
> __err |= ios_base::failbit;
> __n = __gnu_cxx::__numeric_traits<int>::__max;
> }
> else
> __n = int(__l);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(__streambuf_type* __sbout)
> {
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, false);
> if (__cerb && __sbout)
> {
> try
> {
> bool __ineof;
> if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
> __err |= ios_base::failbit;
> if (__ineof)
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::failbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::failbit); }
> }
> else if (!__sbout)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_istream<_CharT, _Traits>::int_type
> basic_istream<_CharT, _Traits>::
> get(void)
> {
> const int_type __eof = traits_type::eof();
> int_type __c = __eof;
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> __c = this->rdbuf()->sbumpc();
>
> if (!traits_type::eq_int_type(__c, __eof))
> _M_gcount = 1;
> else
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return __c;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> get(char_type& __c)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __cb = this->rdbuf()->sbumpc();
>
> if (!traits_type::eq_int_type(__cb, traits_type::eof()))
> {
> _M_gcount = 1;
> __c = traits_type::to_char_type(__cb);
> }
> else
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> get(char_type* __s, streamsize __n, char_type __delim)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __idelim = traits_type::to_int_type(__delim);
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
>
> while (_M_gcount + 1 < __n
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __idelim))
> {
> *__s++ = traits_type::to_char_type(__c);
> ++_M_gcount;
> __c = __sb->snextc();
> }
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
>
>
> if (__n > 0)
> *__s = char_type();
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> get(__streambuf_type& __sb, char_type __delim)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __idelim = traits_type::to_int_type(__delim);
> const int_type __eof = traits_type::eof();
> __streambuf_type* __this_sb = this->rdbuf();
> int_type __c = __this_sb->sgetc();
> char_type __c2 = traits_type::to_char_type(__c);
>
> while (!traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __idelim)
> && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
> {
> ++_M_gcount;
> __c = __this_sb->snextc();
> __c2 = traits_type::to_char_type(__c);
> }
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> getline(char_type* __s, streamsize __n, char_type __delim)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __idelim = traits_type::to_int_type(__delim);
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
>
> while (_M_gcount + 1 < __n
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __idelim))
> {
> *__s++ = traits_type::to_char_type(__c);
> __c = __sb->snextc();
> ++_M_gcount;
> }
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> else
> {
> if (traits_type::eq_int_type(__c, __idelim))
> {
> __sb->sbumpc();
> ++_M_gcount;
> }
> else
> __err |= ios_base::failbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
>
>
> if (__n > 0)
> *__s = char_type();
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
>
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> ignore(void)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
>
> if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
> __err |= ios_base::eofbit;
> else
> _M_gcount = 1;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> ignore(streamsize __n)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb && __n > 0)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
># 513 "/usr/include/c++/4.8.2/bits/istream.tcc" 3
> bool __large_ignore = false;
> while (true)
> {
> while (_M_gcount < __n
> && !traits_type::eq_int_type(__c, __eof))
> {
> ++_M_gcount;
> __c = __sb->snextc();
> }
> if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
> && !traits_type::eq_int_type(__c, __eof))
> {
> _M_gcount =
> __gnu_cxx::__numeric_traits<streamsize>::__min;
> __large_ignore = true;
> }
> else
> break;
> }
>
> if (__large_ignore)
> _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
>
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> ignore(streamsize __n, int_type __delim)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb && __n > 0)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
>
>
> bool __large_ignore = false;
> while (true)
> {
> while (_M_gcount < __n
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __delim))
> {
> ++_M_gcount;
> __c = __sb->snextc();
> }
> if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __delim))
> {
> _M_gcount =
> __gnu_cxx::__numeric_traits<streamsize>::__min;
> __large_ignore = true;
> }
> else
> break;
> }
>
> if (__large_ignore)
> _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
>
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> else if (traits_type::eq_int_type(__c, __delim))
> {
> if (_M_gcount
> < __gnu_cxx::__numeric_traits<streamsize>::__max)
> ++_M_gcount;
> __sb->sbumpc();
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_istream<_CharT, _Traits>::int_type
> basic_istream<_CharT, _Traits>::
> peek(void)
> {
> int_type __c = traits_type::eof();
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> __c = this->rdbuf()->sgetc();
> if (traits_type::eq_int_type(__c, traits_type::eof()))
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return __c;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> read(char_type* __s, streamsize __n)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> _M_gcount = this->rdbuf()->sgetn(__s, __n);
> if (_M_gcount != __n)
> __err |= (ios_base::eofbit | ios_base::failbit);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> streamsize
> basic_istream<_CharT, _Traits>::
> readsome(char_type* __s, streamsize __n)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
>
> const streamsize __num = this->rdbuf()->in_avail();
> if (__num > 0)
> _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
> else if (__num == -1)
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return _M_gcount;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> putback(char_type __c)
> {
>
>
> _M_gcount = 0;
>
> this->clear(this->rdstate() & ~ios_base::eofbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> if (!__sb
> || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> unget(void)
> {
>
>
> _M_gcount = 0;
>
> this->clear(this->rdstate() & ~ios_base::eofbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> if (!__sb
> || traits_type::eq_int_type(__sb->sungetc(), __eof))
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> int
> basic_istream<_CharT, _Traits>::
> sync(void)
> {
>
>
> int __ret = -1;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> __streambuf_type* __sb = this->rdbuf();
> if (__sb)
> {
> if (__sb->pubsync() == -1)
> __err |= ios_base::badbit;
> else
> __ret = 0;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_istream<_CharT, _Traits>::pos_type
> basic_istream<_CharT, _Traits>::
> tellg(void)
> {
>
>
> pos_type __ret = pos_type(-1);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> if (!this->fail())
> __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
> ios_base::in);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> seekg(pos_type __pos)
> {
>
>
>
> this->clear(this->rdstate() & ~ios_base::eofbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> if (!this->fail())
> {
>
> const pos_type __p = this->rdbuf()->pubseekpos(__pos,
> ios_base::in);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> seekg(off_type __off, ios_base::seekdir __dir)
> {
>
>
>
> this->clear(this->rdstate() & ~ios_base::eofbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> if (!this->fail())
> {
>
> const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
> ios_base::in);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::int_type __int_type;
>
> typename __istream_type::sentry __cerb(__in, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const __int_type __cb = __in.rdbuf()->sbumpc();
> if (!_Traits::eq_int_type(__cb, _Traits::eof()))
> __c = _Traits::to_char_type(__cb);
> else
> __err |= (ios_base::eofbit | ios_base::failbit);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __in._M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { __in._M_setstate(ios_base::badbit); }
> if (__err)
> __in.setstate(__err);
> }
> return __in;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef typename _Traits::int_type int_type;
> typedef _CharT char_type;
> typedef ctype<_CharT> __ctype_type;
>
> streamsize __extracted = 0;
> ios_base::iostate __err = ios_base::goodbit;
> typename __istream_type::sentry __cerb(__in, false);
> if (__cerb)
> {
> try
> {
>
> streamsize __num = __in.width();
> if (__num <= 0)
> __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
>
> const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
>
> const int_type __eof = _Traits::eof();
> __streambuf_type* __sb = __in.rdbuf();
> int_type __c = __sb->sgetc();
>
> while (__extracted < __num - 1
> && !_Traits::eq_int_type(__c, __eof)
> && !__ct.is(ctype_base::space,
> _Traits::to_char_type(__c)))
> {
> *__s++ = _Traits::to_char_type(__c);
> ++__extracted;
> __c = __sb->snextc();
> }
> if (_Traits::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
>
>
>
> *__s = char_type();
> __in.width(0);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __in._M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { __in._M_setstate(ios_base::badbit); }
> }
> if (!__extracted)
> __err |= ios_base::failbit;
> if (__err)
> __in.setstate(__err);
> return __in;
> }
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> ws(basic_istream<_CharT, _Traits>& __in)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef typename __istream_type::int_type __int_type;
> typedef ctype<_CharT> __ctype_type;
>
> const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
> const __int_type __eof = _Traits::eof();
> __streambuf_type* __sb = __in.rdbuf();
> __int_type __c = __sb->sgetc();
>
> while (!_Traits::eq_int_type(__c, __eof)
> && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
> __c = __sb->snextc();
>
> if (_Traits::eq_int_type(__c, __eof))
> __in.setstate(ios_base::eofbit);
> return __in;
> }
>
>
>
>
> extern template class basic_istream<char>;
> extern template istream& ws(istream&);
> extern template istream& operator>>(istream&, char&);
> extern template istream& operator>>(istream&, char*);
> extern template istream& operator>>(istream&, unsigned char&);
> extern template istream& operator>>(istream&, signed char&);
> extern template istream& operator>>(istream&, unsigned char*);
> extern template istream& operator>>(istream&, signed char*);
>
> extern template istream& istream::_M_extract(unsigned short&);
> extern template istream& istream::_M_extract(unsigned int&);
> extern template istream& istream::_M_extract(long&);
> extern template istream& istream::_M_extract(unsigned long&);
> extern template istream& istream::_M_extract(bool&);
>
> extern template istream& istream::_M_extract(long long&);
> extern template istream& istream::_M_extract(unsigned long long&);
>
> extern template istream& istream::_M_extract(float&);
> extern template istream& istream::_M_extract(double&);
> extern template istream& istream::_M_extract(long double&);
> extern template istream& istream::_M_extract(void*&);
>
> extern template class basic_iostream<char>;
>
>
> extern template class basic_istream<wchar_t>;
> extern template wistream& ws(wistream&);
> extern template wistream& operator>>(wistream&, wchar_t&);
> extern template wistream& operator>>(wistream&, wchar_t*);
>
> extern template wistream& wistream::_M_extract(unsigned short&);
> extern template wistream& wistream::_M_extract(unsigned int&);
> extern template wistream& wistream::_M_extract(long&);
> extern template wistream& wistream::_M_extract(unsigned long&);
> extern template wistream& wistream::_M_extract(bool&);
>
> extern template wistream& wistream::_M_extract(long long&);
> extern template wistream& wistream::_M_extract(unsigned long long&);
>
> extern template wistream& wistream::_M_extract(float&);
> extern template wistream& wistream::_M_extract(double&);
> extern template wistream& wistream::_M_extract(long double&);
> extern template wistream& wistream::_M_extract(void*&);
>
> extern template class basic_iostream<wchar_t>;
>
>
>
>
>}
># 880 "/usr/include/c++/4.8.2/istream" 2 3
># 39 "/usr/include/c++/4.8.2/sstream" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 63 "/usr/include/c++/4.8.2/sstream" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
>
>
> typedef _Alloc allocator_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
> typedef basic_streambuf<char_type, traits_type> __streambuf_type;
> typedef basic_string<char_type, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
>
> protected:
>
> ios_base::openmode _M_mode;
>
>
> __string_type _M_string;
>
> public:
># 97 "/usr/include/c++/4.8.2/sstream" 3
> explicit
> basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
> : __streambuf_type(), _M_mode(__mode), _M_string()
> { }
># 110 "/usr/include/c++/4.8.2/sstream" 3
> explicit
> basic_stringbuf(const __string_type& __str,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size())
> { _M_stringbuf_init(__mode); }
># 125 "/usr/include/c++/4.8.2/sstream" 3
> __string_type
> str() const
> {
> __string_type __ret;
> if (this->pptr())
> {
>
> if (this->pptr() > this->egptr())
> __ret = __string_type(this->pbase(), this->pptr());
> else
> __ret = __string_type(this->pbase(), this->egptr());
> }
> else
> __ret = _M_string;
> return __ret;
> }
># 149 "/usr/include/c++/4.8.2/sstream" 3
> void
> str(const __string_type& __s)
> {
>
> _M_string.assign(__s.data(), __s.size());
> _M_stringbuf_init(_M_mode);
> }
>
> protected:
>
> void
> _M_stringbuf_init(ios_base::openmode __mode)
> {
> _M_mode = __mode;
> __size_type __len = 0;
> if (_M_mode & (ios_base::ate | ios_base::app))
> __len = _M_string.size();
> _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
> }
>
> virtual streamsize
> showmanyc()
> {
> streamsize __ret = -1;
> if (_M_mode & ios_base::in)
> {
> _M_update_egptr();
> __ret = this->egptr() - this->gptr();
> }
> return __ret;
> }
>
> virtual int_type
> underflow();
>
> virtual int_type
> pbackfail(int_type __c = traits_type::eof());
>
> virtual int_type
> overflow(int_type __c = traits_type::eof());
># 201 "/usr/include/c++/4.8.2/sstream" 3
> virtual __streambuf_type*
> setbuf(char_type* __s, streamsize __n)
> {
> if (__s && __n >= 0)
> {
>
>
>
>
>
>
> _M_string.clear();
>
>
> _M_sync(__s, __n, 0);
> }
> return this;
> }
>
> virtual pos_type
> seekoff(off_type __off, ios_base::seekdir __way,
> ios_base::openmode __mode = ios_base::in | ios_base::out);
>
> virtual pos_type
> seekpos(pos_type __sp,
> ios_base::openmode __mode = ios_base::in | ios_base::out);
>
>
>
>
> void
> _M_sync(char_type* __base, __size_type __i, __size_type __o);
>
>
>
> void
> _M_update_egptr()
> {
> const bool __testin = _M_mode & ios_base::in;
> if (this->pptr() && this->pptr() > this->egptr())
> {
> if (__testin)
> this->setg(this->eback(), this->gptr(), this->pptr());
> else
> this->setg(this->pptr(), this->pptr(), this->pptr());
> }
> }
>
>
>
> void
> _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
> };
># 271 "/usr/include/c++/4.8.2/sstream" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> class basic_istringstream : public basic_istream<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
>
>
> typedef _Alloc allocator_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
> typedef basic_istream<char_type, traits_type> __istream_type;
>
> private:
> __stringbuf_type _M_stringbuf;
>
> public:
># 307 "/usr/include/c++/4.8.2/sstream" 3
> explicit
> basic_istringstream(ios_base::openmode __mode = ios_base::in)
> : __istream_type(), _M_stringbuf(__mode | ios_base::in)
> { this->init(&_M_stringbuf); }
># 325 "/usr/include/c++/4.8.2/sstream" 3
> explicit
> basic_istringstream(const __string_type& __str,
> ios_base::openmode __mode = ios_base::in)
> : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
> { this->init(&_M_stringbuf); }
>
>
>
>
>
>
>
> ~basic_istringstream()
> { }
># 347 "/usr/include/c++/4.8.2/sstream" 3
> __stringbuf_type*
> rdbuf() const
> { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
>
>
>
>
>
> __string_type
> str() const
> { return _M_stringbuf.str(); }
>
>
>
>
>
>
>
> void
> str(const __string_type& __s)
> { _M_stringbuf.str(__s); }
> };
># 386 "/usr/include/c++/4.8.2/sstream" 3
> template <typename _CharT, typename _Traits, typename _Alloc>
> class basic_ostringstream : public basic_ostream<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
>
>
> typedef _Alloc allocator_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
> typedef basic_ostream<char_type, traits_type> __ostream_type;
>
> private:
> __stringbuf_type _M_stringbuf;
>
> public:
># 422 "/usr/include/c++/4.8.2/sstream" 3
> explicit
> basic_ostringstream(ios_base::openmode __mode = ios_base::out)
> : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
> { this->init(&_M_stringbuf); }
># 440 "/usr/include/c++/4.8.2/sstream" 3
> explicit
> basic_ostringstream(const __string_type& __str,
> ios_base::openmode __mode = ios_base::out)
> : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
> { this->init(&_M_stringbuf); }
>
>
>
>
>
>
>
> ~basic_ostringstream()
> { }
># 462 "/usr/include/c++/4.8.2/sstream" 3
> __stringbuf_type*
> rdbuf() const
> { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
>
>
>
>
>
> __string_type
> str() const
> { return _M_stringbuf.str(); }
>
>
>
>
>
>
>
> void
> str(const __string_type& __s)
> { _M_stringbuf.str(__s); }
> };
># 501 "/usr/include/c++/4.8.2/sstream" 3
> template <typename _CharT, typename _Traits, typename _Alloc>
> class basic_stringstream : public basic_iostream<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
>
>
> typedef _Alloc allocator_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
> typedef basic_iostream<char_type, traits_type> __iostream_type;
>
> private:
> __stringbuf_type _M_stringbuf;
>
> public:
># 536 "/usr/include/c++/4.8.2/sstream" 3
> explicit
> basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
> : __iostream_type(), _M_stringbuf(__m)
> { this->init(&_M_stringbuf); }
># 552 "/usr/include/c++/4.8.2/sstream" 3
> explicit
> basic_stringstream(const __string_type& __str,
> ios_base::openmode __m = ios_base::out | ios_base::in)
> : __iostream_type(), _M_stringbuf(__str, __m)
> { this->init(&_M_stringbuf); }
>
>
>
>
>
>
>
> ~basic_stringstream()
> { }
># 574 "/usr/include/c++/4.8.2/sstream" 3
> __stringbuf_type*
> rdbuf() const
> { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
>
>
>
>
>
> __string_type
> str() const
> { return _M_stringbuf.str(); }
>
>
>
>
>
>
>
> void
> str(const __string_type& __s)
> { _M_stringbuf.str(__s); }
> };
>
>
>}
>
># 1 "/usr/include/c++/4.8.2/bits/sstream.tcc" 1 3
># 37 "/usr/include/c++/4.8.2/bits/sstream.tcc" 3
> 
># 38 "/usr/include/c++/4.8.2/bits/sstream.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> pbackfail(int_type __c)
> {
> int_type __ret = traits_type::eof();
> if (this->eback() < this->gptr())
> {
>
>
> const bool __testeof = traits_type::eq_int_type(__c, __ret);
> if (!__testeof)
> {
> const bool __testeq = traits_type::eq(traits_type::
> to_char_type(__c),
> this->gptr()[-1]);
> const bool __testout = this->_M_mode & ios_base::out;
> if (__testeq || __testout)
> {
> this->gbump(-1);
> if (!__testeq)
> *this->gptr() = traits_type::to_char_type(__c);
> __ret = __c;
> }
> }
> else
> {
> this->gbump(-1);
> __ret = traits_type::not_eof(__c);
> }
> }
> return __ret;
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> overflow(int_type __c)
> {
> const bool __testout = this->_M_mode & ios_base::out;
> if (__builtin_expect(!__testout, false))
> return traits_type::eof();
>
> const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
> if (__builtin_expect(__testeof, false))
> return traits_type::not_eof(__c);
>
> const __size_type __capacity = _M_string.capacity();
> const __size_type __max_size = _M_string.max_size();
> const bool __testput = this->pptr() < this->epptr();
> if (__builtin_expect(!__testput && __capacity == __max_size, false))
> return traits_type::eof();
>
>
>
> const char_type __conv = traits_type::to_char_type(__c);
> if (!__testput)
> {
># 110 "/usr/include/c++/4.8.2/bits/sstream.tcc" 3
> const __size_type __opt_len = std::max(__size_type(2 * __capacity),
> __size_type(512));
> const __size_type __len = std::min(__opt_len, __max_size);
> __string_type __tmp;
> __tmp.reserve(__len);
> if (this->pbase())
> __tmp.assign(this->pbase(), this->epptr() - this->pbase());
> __tmp.push_back(__conv);
> _M_string.swap(__tmp);
> _M_sync(const_cast<char_type*>(_M_string.data()),
> this->gptr() - this->eback(), this->pptr() - this->pbase());
> }
> else
> *this->pptr() = __conv;
> this->pbump(1);
> return __c;
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> underflow()
> {
> int_type __ret = traits_type::eof();
> const bool __testin = this->_M_mode & ios_base::in;
> if (__testin)
> {
>
> _M_update_egptr();
>
> if (this->gptr() < this->egptr())
> __ret = traits_type::to_int_type(*this->gptr());
> }
> return __ret;
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
> {
> pos_type __ret = pos_type(off_type(-1));
> bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
> bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
> const bool __testboth = __testin && __testout && __way != ios_base::cur;
> __testin &= !(__mode & ios_base::out);
> __testout &= !(__mode & ios_base::in);
>
>
>
> const char_type* __beg = __testin ? this->eback() : this->pbase();
> if ((__beg || !__off) && (__testin || __testout || __testboth))
> {
> _M_update_egptr();
>
> off_type __newoffi = __off;
> off_type __newoffo = __newoffi;
> if (__way == ios_base::cur)
> {
> __newoffi += this->gptr() - __beg;
> __newoffo += this->pptr() - __beg;
> }
> else if (__way == ios_base::end)
> __newoffo = __newoffi += this->egptr() - __beg;
>
> if ((__testin || __testboth)
> && __newoffi >= 0
> && this->egptr() - __beg >= __newoffi)
> {
> this->setg(this->eback(), this->eback() + __newoffi,
> this->egptr());
> __ret = pos_type(__newoffi);
> }
> if ((__testout || __testboth)
> && __newoffo >= 0
> && this->egptr() - __beg >= __newoffo)
> {
> _M_pbump(this->pbase(), this->epptr(), __newoffo);
> __ret = pos_type(__newoffo);
> }
> }
> return __ret;
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> seekpos(pos_type __sp, ios_base::openmode __mode)
> {
> pos_type __ret = pos_type(off_type(-1));
> const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
> const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
>
> const char_type* __beg = __testin ? this->eback() : this->pbase();
> if ((__beg || !off_type(__sp)) && (__testin || __testout))
> {
> _M_update_egptr();
>
> const off_type __pos(__sp);
> const bool __testpos = (0 <= __pos
> && __pos <= this->egptr() - __beg);
> if (__testpos)
> {
> if (__testin)
> this->setg(this->eback(), this->eback() + __pos,
> this->egptr());
> if (__testout)
> _M_pbump(this->pbase(), this->epptr(), __pos);
> __ret = __sp;
> }
> }
> return __ret;
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> void
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> _M_sync(char_type* __base, __size_type __i, __size_type __o)
> {
> const bool __testin = _M_mode & ios_base::in;
> const bool __testout = _M_mode & ios_base::out;
> char_type* __endg = __base + _M_string.size();
> char_type* __endp = __base + _M_string.capacity();
>
> if (__base != _M_string.data())
> {
>
> __endg += __i;
> __i = 0;
> __endp = __endg;
> }
>
> if (__testin)
> this->setg(__base, __base + __i, __endg);
> if (__testout)
> {
> _M_pbump(__base, __endp, __o);
>
>
>
> if (!__testin)
> this->setg(__endg, __endg, __endg);
> }
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> void
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off)
> {
> this->setp(__pbeg, __pend);
> while (__off > __gnu_cxx::__numeric_traits<int>::__max)
> {
> this->pbump(__gnu_cxx::__numeric_traits<int>::__max);
> __off -= __gnu_cxx::__numeric_traits<int>::__max;
> }
> this->pbump(__off);
> }
>
>
>
>
> extern template class basic_stringbuf<char>;
> extern template class basic_istringstream<char>;
> extern template class basic_ostringstream<char>;
> extern template class basic_stringstream<char>;
>
>
> extern template class basic_stringbuf<wchar_t>;
> extern template class basic_istringstream<wchar_t>;
> extern template class basic_ostringstream<wchar_t>;
> extern template class basic_stringstream<wchar_t>;
>
>
>
>
>}
># 601 "/usr/include/c++/4.8.2/sstream" 2 3
># 46 "/usr/include/c++/4.8.2/complex" 2 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 63 "/usr/include/c++/4.8.2/complex" 3
> template<typename _Tp> class complex;
> template<> class complex<float>;
> template<> class complex<double>;
> template<> class complex<long double>;
>
>
> template<typename _Tp> _Tp abs(const complex<_Tp>&);
>
> template<typename _Tp> _Tp arg(const complex<_Tp>&);
>
> template<typename _Tp> _Tp norm(const complex<_Tp>&);
>
>
> template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
>
>
>
> template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
>
>
>
>
>
>
> template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
>
> template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
> const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
>
> template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
># 124 "/usr/include/c++/4.8.2/complex" 3
> template<typename _Tp>
> struct complex
> {
>
> typedef _Tp value_type;
>
>
>
> constexpr complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
> : _M_real(__r), _M_imag(__i) { }
>
>
>
>
> template<typename _Up>
> constexpr complex(const complex<_Up>& __z)
> : _M_real(__z.real()), _M_imag(__z.imag()) { }
>
>
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> constexpr _Tp
> real() { return _M_real; }
>
> __attribute ((__abi_tag__ ("cxx11")))
> constexpr _Tp
> imag() { return _M_imag; }
># 172 "/usr/include/c++/4.8.2/complex" 3
> void
> real(_Tp __val) { _M_real = __val; }
>
> void
> imag(_Tp __val) { _M_imag = __val; }
>
>
> complex<_Tp>& operator=(const _Tp&);
>
>
>
> complex<_Tp>&
> operator+=(const _Tp& __t)
> {
> _M_real += __t;
> return *this;
> }
>
>
>
> complex<_Tp>&
> operator-=(const _Tp& __t)
> {
> _M_real -= __t;
> return *this;
> }
>
>
> complex<_Tp>& operator*=(const _Tp&);
>
> complex<_Tp>& operator/=(const _Tp&);
>
>
>
>
>
> template<typename _Up>
> complex<_Tp>& operator=(const complex<_Up>&);
>
> template<typename _Up>
> complex<_Tp>& operator+=(const complex<_Up>&);
>
> template<typename _Up>
> complex<_Tp>& operator-=(const complex<_Up>&);
>
> template<typename _Up>
> complex<_Tp>& operator*=(const complex<_Up>&);
>
> template<typename _Up>
> complex<_Tp>& operator/=(const complex<_Up>&);
>
> constexpr complex __rep() const
> { return *this; }
>
> private:
> _Tp _M_real;
> _Tp _M_imag;
> };
>
> template<typename _Tp>
> complex<_Tp>&
> complex<_Tp>::operator=(const _Tp& __t)
> {
> _M_real = __t;
> _M_imag = _Tp();
> return *this;
> }
>
>
> template<typename _Tp>
> complex<_Tp>&
> complex<_Tp>::operator*=(const _Tp& __t)
> {
> _M_real *= __t;
> _M_imag *= __t;
> return *this;
> }
>
>
> template<typename _Tp>
> complex<_Tp>&
> complex<_Tp>::operator/=(const _Tp& __t)
> {
> _M_real /= __t;
> _M_imag /= __t;
> return *this;
> }
>
> template<typename _Tp>
> template<typename _Up>
> complex<_Tp>&
> complex<_Tp>::operator=(const complex<_Up>& __z)
> {
> _M_real = __z.real();
> _M_imag = __z.imag();
> return *this;
> }
>
>
> template<typename _Tp>
> template<typename _Up>
> complex<_Tp>&
> complex<_Tp>::operator+=(const complex<_Up>& __z)
> {
> _M_real += __z.real();
> _M_imag += __z.imag();
> return *this;
> }
>
>
> template<typename _Tp>
> template<typename _Up>
> complex<_Tp>&
> complex<_Tp>::operator-=(const complex<_Up>& __z)
> {
> _M_real -= __z.real();
> _M_imag -= __z.imag();
> return *this;
> }
>
>
>
> template<typename _Tp>
> template<typename _Up>
> complex<_Tp>&
> complex<_Tp>::operator*=(const complex<_Up>& __z)
> {
> const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
> _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
> _M_real = __r;
> return *this;
> }
>
>
>
> template<typename _Tp>
> template<typename _Up>
> complex<_Tp>&
> complex<_Tp>::operator/=(const complex<_Up>& __z)
> {
> const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
> const _Tp __n = std::norm(__z);
> _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
> _M_real = __r / __n;
> return *this;
> }
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r = __x;
> __r += __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator+(const complex<_Tp>& __x, const _Tp& __y)
> {
> complex<_Tp> __r = __x;
> __r += __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator+(const _Tp& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r = __y;
> __r += __x;
> return __r;
> }
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r = __x;
> __r -= __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator-(const complex<_Tp>& __x, const _Tp& __y)
> {
> complex<_Tp> __r = __x;
> __r -= __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator-(const _Tp& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r(__x, -__y.imag());
> __r -= __y.real();
> return __r;
> }
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r = __x;
> __r *= __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator*(const complex<_Tp>& __x, const _Tp& __y)
> {
> complex<_Tp> __r = __x;
> __r *= __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator*(const _Tp& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r = __y;
> __r *= __x;
> return __r;
> }
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r = __x;
> __r /= __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator/(const complex<_Tp>& __x, const _Tp& __y)
> {
> complex<_Tp> __r = __x;
> __r /= __y;
> return __r;
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> operator/(const _Tp& __x, const complex<_Tp>& __y)
> {
> complex<_Tp> __r = __x;
> __r /= __y;
> return __r;
> }
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> operator+(const complex<_Tp>& __x)
> { return __x; }
>
>
> template<typename _Tp>
> inline complex<_Tp>
> operator-(const complex<_Tp>& __x)
> { return complex<_Tp>(-__x.real(), -__x.imag()); }
>
>
>
> template<typename _Tp>
> inline constexpr bool
> operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
> { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
>
> template<typename _Tp>
> inline constexpr bool
> operator==(const complex<_Tp>& __x, const _Tp& __y)
> { return __x.real() == __y && __x.imag() == _Tp(); }
>
> template<typename _Tp>
> inline constexpr bool
> operator==(const _Tp& __x, const complex<_Tp>& __y)
> { return __x == __y.real() && _Tp() == __y.imag(); }
>
>
>
>
> template<typename _Tp>
> inline constexpr bool
> operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
> { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
>
> template<typename _Tp>
> inline constexpr bool
> operator!=(const complex<_Tp>& __x, const _Tp& __y)
> { return __x.real() != __y || __x.imag() != _Tp(); }
>
> template<typename _Tp>
> inline constexpr bool
> operator!=(const _Tp& __x, const complex<_Tp>& __y)
> { return __x != __y.real() || _Tp() != __y.imag(); }
>
>
>
> template<typename _Tp, typename _CharT, class _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
> {
> _Tp __re_x, __im_x;
> _CharT __ch;
> __is >> __ch;
> if (__ch == '(')
> {
> __is >> __re_x >> __ch;
> if (__ch == ',')
> {
> __is >> __im_x >> __ch;
> if (__ch == ')')
> __x = complex<_Tp>(__re_x, __im_x);
> else
> __is.setstate(ios_base::failbit);
> }
> else if (__ch == ')')
> __x = __re_x;
> else
> __is.setstate(ios_base::failbit);
> }
> else
> {
> __is.putback(__ch);
> __is >> __re_x;
> __x = __re_x;
> }
> return __is;
> }
>
>
> template<typename _Tp, typename _CharT, class _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
> {
> basic_ostringstream<_CharT, _Traits> __s;
> __s.flags(__os.flags());
> __s.imbue(__os.getloc());
> __s.precision(__os.precision());
> __s << '(' << __x.real() << ',' << __x.imag() << ')';
> return __os << __s.str();
> }
>
>
>
> template<typename _Tp>
> constexpr _Tp
> real(const complex<_Tp>& __z)
> { return __z.real(); }
>
> template<typename _Tp>
> constexpr _Tp
> imag(const complex<_Tp>& __z)
> { return __z.imag(); }
># 568 "/usr/include/c++/4.8.2/complex" 3
> template<typename _Tp>
> inline _Tp
> __complex_abs(const complex<_Tp>& __z)
> {
> _Tp __x = __z.real();
> _Tp __y = __z.imag();
> const _Tp __s = std::max(abs(__x), abs(__y));
> if (__s == _Tp())
> return __s;
> __x /= __s;
> __y /= __s;
> return __s * sqrt(__x * __x + __y * __y);
> }
>
>
> inline float
> __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
>
> inline double
> __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
>
> inline long double
> __complex_abs(const __complex__ long double& __z)
> { return __builtin_cabsl(__z); }
>
> template<typename _Tp>
> inline _Tp
> abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
># 604 "/usr/include/c++/4.8.2/complex" 3
> template<typename _Tp>
> inline _Tp
> __complex_arg(const complex<_Tp>& __z)
> { return atan2(__z.imag(), __z.real()); }
>
>
> inline float
> __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
>
> inline double
> __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
>
> inline long double
> __complex_arg(const __complex__ long double& __z)
> { return __builtin_cargl(__z); }
>
> template<typename _Tp>
> inline _Tp
> arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
># 634 "/usr/include/c++/4.8.2/complex" 3
> template<bool>
> struct _Norm_helper
> {
> template<typename _Tp>
> static inline _Tp _S_do_it(const complex<_Tp>& __z)
> {
> const _Tp __x = __z.real();
> const _Tp __y = __z.imag();
> return __x * __x + __y * __y;
> }
> };
>
> template<>
> struct _Norm_helper<true>
> {
> template<typename _Tp>
> static inline _Tp _S_do_it(const complex<_Tp>& __z)
> {
> _Tp __res = std::abs(__z);
> return __res * __res;
> }
> };
>
> template<typename _Tp>
> inline _Tp
> norm(const complex<_Tp>& __z)
> {
> return _Norm_helper<__is_floating<_Tp>::__value
> && !0>::_S_do_it(__z);
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> polar(const _Tp& __rho, const _Tp& __theta)
> { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
>
> template<typename _Tp>
> inline complex<_Tp>
> conj(const complex<_Tp>& __z)
> { return complex<_Tp>(__z.real(), -__z.imag()); }
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> __complex_cos(const complex<_Tp>& __z)
> {
> const _Tp __x = __z.real();
> const _Tp __y = __z.imag();
> return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
> }
>
>
> inline __complex__ float
> __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
>
> inline __complex__ double
> __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
>
> inline __complex__ long double
> __complex_cos(const __complex__ long double& __z)
> { return __builtin_ccosl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
>
>
>
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> __complex_cosh(const complex<_Tp>& __z)
> {
> const _Tp __x = __z.real();
> const _Tp __y = __z.imag();
> return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
> }
>
>
> inline __complex__ float
> __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
>
> inline __complex__ double
> __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
>
> inline __complex__ long double
> __complex_cosh(const __complex__ long double& __z)
> { return __builtin_ccoshl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
>
>
>
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> __complex_exp(const complex<_Tp>& __z)
> { return std::polar(exp(__z.real()), __z.imag()); }
>
>
> inline __complex__ float
> __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
>
> inline __complex__ double
> __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
>
> inline __complex__ long double
> __complex_exp(const __complex__ long double& __z)
> { return __builtin_cexpl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
># 765 "/usr/include/c++/4.8.2/complex" 3
> template<typename _Tp>
> inline complex<_Tp>
> __complex_log(const complex<_Tp>& __z)
> { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
>
>
> inline __complex__ float
> __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
>
> inline __complex__ double
> __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
>
> inline __complex__ long double
> __complex_log(const __complex__ long double& __z)
> { return __builtin_clogl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
>
>
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> log10(const complex<_Tp>& __z)
> { return std::log(__z) / log(_Tp(10.0)); }
>
>
> template<typename _Tp>
> inline complex<_Tp>
> __complex_sin(const complex<_Tp>& __z)
> {
> const _Tp __x = __z.real();
> const _Tp __y = __z.imag();
> return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
> }
>
>
> inline __complex__ float
> __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
>
> inline __complex__ double
> __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
>
> inline __complex__ long double
> __complex_sin(const __complex__ long double& __z)
> { return __builtin_csinl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
>
>
>
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> __complex_sinh(const complex<_Tp>& __z)
> {
> const _Tp __x = __z.real();
> const _Tp __y = __z.imag();
> return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
> }
>
>
> inline __complex__ float
> __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
>
> inline __complex__ double
> __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
>
> inline __complex__ long double
> __complex_sinh(const __complex__ long double& __z)
> { return __builtin_csinhl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
># 857 "/usr/include/c++/4.8.2/complex" 3
> template<typename _Tp>
> complex<_Tp>
> __complex_sqrt(const complex<_Tp>& __z)
> {
> _Tp __x = __z.real();
> _Tp __y = __z.imag();
>
> if (__x == _Tp())
> {
> _Tp __t = sqrt(abs(__y) / 2);
> return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
> }
> else
> {
> _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
> _Tp __u = __t / 2;
> return __x > _Tp()
> ? complex<_Tp>(__u, __y / __t)
> : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
> }
> }
>
>
> inline __complex__ float
> __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
>
> inline __complex__ double
> __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
>
> inline __complex__ long double
> __complex_sqrt(const __complex__ long double& __z)
> { return __builtin_csqrtl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
># 901 "/usr/include/c++/4.8.2/complex" 3
> template<typename _Tp>
> inline complex<_Tp>
> __complex_tan(const complex<_Tp>& __z)
> { return std::sin(__z) / std::cos(__z); }
>
>
> inline __complex__ float
> __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
>
> inline __complex__ double
> __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
>
> inline __complex__ long double
> __complex_tan(const __complex__ long double& __z)
> { return __builtin_ctanl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
># 929 "/usr/include/c++/4.8.2/complex" 3
> template<typename _Tp>
> inline complex<_Tp>
> __complex_tanh(const complex<_Tp>& __z)
> { return std::sinh(__z) / std::cosh(__z); }
>
>
> inline __complex__ float
> __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
>
> inline __complex__ double
> __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
>
> inline __complex__ long double
> __complex_tanh(const __complex__ long double& __z)
> { return __builtin_ctanhl(__z); }
>
> template<typename _Tp>
> inline complex<_Tp>
> tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
># 987 "/usr/include/c++/4.8.2/complex" 3
> template<typename _Tp>
> complex<_Tp>
> pow(const complex<_Tp>& __x, const _Tp& __y)
> {
>
>
>
>
> if (__x.imag() == _Tp() && __x.real() > _Tp())
> return pow(__x.real(), __y);
>
> complex<_Tp> __t = std::log(__x);
> return std::polar(exp(__y * __t.real()), __y * __t.imag());
> }
>
> template<typename _Tp>
> inline complex<_Tp>
> __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
> { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
>
>
> inline __complex__ float
> __complex_pow(__complex__ float __x, __complex__ float __y)
> { return __builtin_cpowf(__x, __y); }
>
> inline __complex__ double
> __complex_pow(__complex__ double __x, __complex__ double __y)
> { return __builtin_cpow(__x, __y); }
>
> inline __complex__ long double
> __complex_pow(const __complex__ long double& __x,
> const __complex__ long double& __y)
> { return __builtin_cpowl(__x, __y); }
>
> template<typename _Tp>
> inline complex<_Tp>
> pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
> { return __complex_pow(__x.__rep(), __y.__rep()); }
>
>
>
>
>
>
>
> template<typename _Tp>
> inline complex<_Tp>
> pow(const _Tp& __x, const complex<_Tp>& __y)
> {
> return __x > _Tp() ? std::polar(pow(__x, __y.real()),
> __y.imag() * log(__x))
> : std::pow(complex<_Tp>(__x), __y);
> }
>
>
>
> template<>
> struct complex<float>
> {
> typedef float value_type;
> typedef __complex__ float _ComplexT;
>
> constexpr complex(_ComplexT __z) : _M_value(__z) { }
>
> constexpr complex(float __r = 0.0f, float __i = 0.0f)
>
> : _M_value{ __r, __i } { }
>
>
>
>
>
>
>
> explicit constexpr complex(const complex<double>&);
> explicit constexpr complex(const complex<long double>&);
>
>
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> constexpr float
> real() { return __real__ _M_value; }
>
> __attribute ((__abi_tag__ ("cxx11")))
> constexpr float
> imag() { return __imag__ _M_value; }
># 1090 "/usr/include/c++/4.8.2/complex" 3
> void
> real(float __val) { __real__ _M_value = __val; }
>
> void
> imag(float __val) { __imag__ _M_value = __val; }
>
> complex&
> operator=(float __f)
> {
> _M_value = __f;
> return *this;
> }
>
> complex&
> operator+=(float __f)
> {
> _M_value += __f;
> return *this;
> }
>
> complex&
> operator-=(float __f)
> {
> _M_value -= __f;
> return *this;
> }
>
> complex&
> operator*=(float __f)
> {
> _M_value *= __f;
> return *this;
> }
>
> complex&
> operator/=(float __f)
> {
> _M_value /= __f;
> return *this;
> }
>
>
>
>
>
> template<typename _Tp>
> complex&
> operator=(const complex<_Tp>& __z)
> {
> __real__ _M_value = __z.real();
> __imag__ _M_value = __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> complex&
> operator+=(const complex<_Tp>& __z)
> {
> __real__ _M_value += __z.real();
> __imag__ _M_value += __z.imag();
> return *this;
> }
>
> template<class _Tp>
> complex&
> operator-=(const complex<_Tp>& __z)
> {
> __real__ _M_value -= __z.real();
> __imag__ _M_value -= __z.imag();
> return *this;
> }
>
> template<class _Tp>
> complex&
> operator*=(const complex<_Tp>& __z)
> {
> _ComplexT __t;
> __real__ __t = __z.real();
> __imag__ __t = __z.imag();
> _M_value *= __t;
> return *this;
> }
>
> template<class _Tp>
> complex&
> operator/=(const complex<_Tp>& __z)
> {
> _ComplexT __t;
> __real__ __t = __z.real();
> __imag__ __t = __z.imag();
> _M_value /= __t;
> return *this;
> }
>
> constexpr _ComplexT __rep() const { return _M_value; }
>
> private:
> _ComplexT _M_value;
> };
>
>
>
> template<>
> struct complex<double>
> {
> typedef double value_type;
> typedef __complex__ double _ComplexT;
>
> constexpr complex(_ComplexT __z) : _M_value(__z) { }
>
> constexpr complex(double __r = 0.0, double __i = 0.0)
>
> : _M_value{ __r, __i } { }
>
>
>
>
>
>
>
> constexpr complex(const complex<float>& __z)
> : _M_value(__z.__rep()) { }
>
> explicit constexpr complex(const complex<long double>&);
>
>
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> constexpr double
> real() { return __real__ _M_value; }
>
> __attribute ((__abi_tag__ ("cxx11")))
> constexpr double
> imag() { return __imag__ _M_value; }
># 1241 "/usr/include/c++/4.8.2/complex" 3
> void
> real(double __val) { __real__ _M_value = __val; }
>
> void
> imag(double __val) { __imag__ _M_value = __val; }
>
> complex&
> operator=(double __d)
> {
> _M_value = __d;
> return *this;
> }
>
> complex&
> operator+=(double __d)
> {
> _M_value += __d;
> return *this;
> }
>
> complex&
> operator-=(double __d)
> {
> _M_value -= __d;
> return *this;
> }
>
> complex&
> operator*=(double __d)
> {
> _M_value *= __d;
> return *this;
> }
>
> complex&
> operator/=(double __d)
> {
> _M_value /= __d;
> return *this;
> }
>
>
>
>
> template<typename _Tp>
> complex&
> operator=(const complex<_Tp>& __z)
> {
> __real__ _M_value = __z.real();
> __imag__ _M_value = __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> complex&
> operator+=(const complex<_Tp>& __z)
> {
> __real__ _M_value += __z.real();
> __imag__ _M_value += __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> complex&
> operator-=(const complex<_Tp>& __z)
> {
> __real__ _M_value -= __z.real();
> __imag__ _M_value -= __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> complex&
> operator*=(const complex<_Tp>& __z)
> {
> _ComplexT __t;
> __real__ __t = __z.real();
> __imag__ __t = __z.imag();
> _M_value *= __t;
> return *this;
> }
>
> template<typename _Tp>
> complex&
> operator/=(const complex<_Tp>& __z)
> {
> _ComplexT __t;
> __real__ __t = __z.real();
> __imag__ __t = __z.imag();
> _M_value /= __t;
> return *this;
> }
>
> constexpr _ComplexT __rep() const { return _M_value; }
>
> private:
> _ComplexT _M_value;
> };
>
>
>
> template<>
> struct complex<long double>
> {
> typedef long double value_type;
> typedef __complex__ long double _ComplexT;
>
> constexpr complex(_ComplexT __z) : _M_value(__z) { }
>
> constexpr complex(long double __r = 0.0L,
> long double __i = 0.0L)
>
> : _M_value{ __r, __i } { }
>
>
>
>
>
>
>
> constexpr complex(const complex<float>& __z)
> : _M_value(__z.__rep()) { }
>
> constexpr complex(const complex<double>& __z)
> : _M_value(__z.__rep()) { }
>
>
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> constexpr long double
> real() { return __real__ _M_value; }
>
> __attribute ((__abi_tag__ ("cxx11")))
> constexpr long double
> imag() { return __imag__ _M_value; }
># 1393 "/usr/include/c++/4.8.2/complex" 3
> void
> real(long double __val) { __real__ _M_value = __val; }
>
> void
> imag(long double __val) { __imag__ _M_value = __val; }
>
> complex&
> operator=(long double __r)
> {
> _M_value = __r;
> return *this;
> }
>
> complex&
> operator+=(long double __r)
> {
> _M_value += __r;
> return *this;
> }
>
> complex&
> operator-=(long double __r)
> {
> _M_value -= __r;
> return *this;
> }
>
> complex&
> operator*=(long double __r)
> {
> _M_value *= __r;
> return *this;
> }
>
> complex&
> operator/=(long double __r)
> {
> _M_value /= __r;
> return *this;
> }
>
>
>
>
> template<typename _Tp>
> complex&
> operator=(const complex<_Tp>& __z)
> {
> __real__ _M_value = __z.real();
> __imag__ _M_value = __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> complex&
> operator+=(const complex<_Tp>& __z)
> {
> __real__ _M_value += __z.real();
> __imag__ _M_value += __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> complex&
> operator-=(const complex<_Tp>& __z)
> {
> __real__ _M_value -= __z.real();
> __imag__ _M_value -= __z.imag();
> return *this;
> }
>
> template<typename _Tp>
> complex&
> operator*=(const complex<_Tp>& __z)
> {
> _ComplexT __t;
> __real__ __t = __z.real();
> __imag__ __t = __z.imag();
> _M_value *= __t;
> return *this;
> }
>
> template<typename _Tp>
> complex&
> operator/=(const complex<_Tp>& __z)
> {
> _ComplexT __t;
> __real__ __t = __z.real();
> __imag__ __t = __z.imag();
> _M_value /= __t;
> return *this;
> }
>
> constexpr _ComplexT __rep() const { return _M_value; }
>
> private:
> _ComplexT _M_value;
> };
>
>
>
> inline constexpr
> complex<float>::complex(const complex<double>& __z)
> : _M_value(__z.__rep()) { }
>
> inline constexpr
> complex<float>::complex(const complex<long double>& __z)
> : _M_value(__z.__rep()) { }
>
> inline constexpr
> complex<double>::complex(const complex<long double>& __z)
> : _M_value(__z.__rep()) { }
>
>
>
>
>
> extern template istream& operator>>(istream&, complex<float>&);
> extern template ostream& operator<<(ostream&, const complex<float>&);
> extern template istream& operator>>(istream&, complex<double>&);
> extern template ostream& operator<<(ostream&, const complex<double>&);
> extern template istream& operator>>(istream&, complex<long double>&);
> extern template ostream& operator<<(ostream&, const complex<long double>&);
>
>
> extern template wistream& operator>>(wistream&, complex<float>&);
> extern template wostream& operator<<(wostream&, const complex<float>&);
> extern template wistream& operator>>(wistream&, complex<double>&);
> extern template wostream& operator<<(wostream&, const complex<double>&);
> extern template wistream& operator>>(wistream&, complex<long double>&);
> extern template wostream& operator<<(wostream&, const complex<long double>&);
>
>
>
>
>
>
>}
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> 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 __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> 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> _Tp fabs(const std::complex<_Tp>&);
>
> template<typename _Tp>
> inline std::complex<_Tp>
> __complex_acos(const std::complex<_Tp>& __z)
> {
> const std::complex<_Tp> __t = std::asin(__z);
> const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
> return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
> }
>
>
> 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()); }
># 1614 "/usr/include/c++/4.8.2/complex" 3
> template<typename _Tp>
> inline std::complex<_Tp>
> __complex_asin(const std::complex<_Tp>& __z)
> {
> std::complex<_Tp> __t(-__z.imag(), __z.real());
> __t = std::asinh(__t);
> return std::complex<_Tp>(__t.imag(), -__t.real());
> }
>
>
> 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()); }
># 1650 "/usr/include/c++/4.8.2/complex" 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));
> }
>
>
> 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()); }
># 1694 "/usr/include/c++/4.8.2/complex" 3
> template<typename _Tp>
> std::complex<_Tp>
> __complex_acosh(const std::complex<_Tp>& __z)
> {
>
> return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
> + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
> }
>
>
> 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()); }
># 1730 "/usr/include/c++/4.8.2/complex" 3
> 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);
> }
>
>
> 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()); }
># 1769 "/usr/include/c++/4.8.2/complex" 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));
> }
>
>
> 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()); }
># 1813 "/usr/include/c++/4.8.2/complex" 3
> template<typename _Tp>
> inline _Tp
>
>
>
> fabs(const std::complex<_Tp>& __z)
> { return std::abs(__z); }
>
>
> template<typename _Tp>
> inline typename __gnu_cxx::__promote<_Tp>::__type
> arg(_Tp __x)
> {
> typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
>
> return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
> : __type();
>
>
>
> }
>
> 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>
> inline typename __gnu_cxx::__promote<_Tp>::__type
> real(_Tp __x)
> { return __x; }
>
> 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> std::complex<_Tp> proj(const std::complex<_Tp>&);
>
> template<typename _Tp>
> std::complex<_Tp>
> __complex_proj(const std::complex<_Tp>& __z)
> {
> const _Tp __den = (__z.real() * __z.real()
> + __z.imag() * __z.imag() + _Tp(1.0));
>
> return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den,
> (_Tp(2.0) * __z.imag()) / __den);
> }
>
>
> inline __complex__ float
> __complex_proj(__complex__ float __z)
> { return __builtin_cprojf(__z); }
>
> inline __complex__ double
> __complex_proj(__complex__ double __z)
> { return __builtin_cproj(__z); }
>
> inline __complex__ long double
> __complex_proj(const __complex__ long double& __z)
> { return __builtin_cprojl(__z); }
>
> template<typename _Tp>
> inline std::complex<_Tp>
> proj(const std::complex<_Tp>& __z)
> { return __complex_proj(__z.__rep()); }
># 1918 "/usr/include/c++/4.8.2/complex" 3
> template<typename _Tp>
> inline typename __gnu_cxx::__promote<_Tp>::__type
> proj(_Tp __x)
> { return __x; }
>
> template<typename _Tp>
> inline typename __gnu_cxx::__promote<_Tp>::__type
> conj(_Tp __x)
> { return __x; }
>
>
>}
># 25 "../src/types.h" 2
>
>typedef std::complex<double> cplx;
>
>
>
>struct position
>{
> double horizontal, vertical;
> position(double h, double v):horizontal(h), vertical(v) {};
> position():horizontal(0), vertical(0) {};
>};
># 18 "../src/wildfire.h" 2
># 1 "/usr/include/c++/4.8.2/vector" 1 3
># 58 "/usr/include/c++/4.8.2/vector" 3
> 
># 59 "/usr/include/c++/4.8.2/vector" 3
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/stl_construct.h" 1 3
># 61 "/usr/include/c++/4.8.2/bits/stl_construct.h" 3
># 1 "/usr/include/c++/4.8.2/ext/alloc_traits.h" 1 3
># 32 "/usr/include/c++/4.8.2/ext/alloc_traits.h" 3
> 
># 33 "/usr/include/c++/4.8.2/ext/alloc_traits.h" 3
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 1 3
># 36 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
># 1 "/usr/include/c++/4.8.2/bits/ptr_traits.h" 1 3
># 37 "/usr/include/c++/4.8.2/bits/ptr_traits.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>template<typename _Tp> class __has_element_type_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::element_type>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_element_type : integral_constant<bool, __has_element_type_helper <typename remove_cv<_Tp>::type>::value> { };
>template<typename _Tp> class __has_difference_type_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::difference_type>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_difference_type : integral_constant<bool, __has_difference_type_helper <typename remove_cv<_Tp>::type>::value> { };
>
> template<typename _Tp, bool = __has_element_type<_Tp>::value>
> struct __ptrtr_elt_type;
>
> template<typename _Tp>
> struct __ptrtr_elt_type<_Tp, true>
> {
> typedef typename _Tp::element_type __type;
> };
>
> template<template<typename, typename...> class _SomePtr, typename _Tp,
> typename... _Args>
> struct __ptrtr_elt_type<_SomePtr<_Tp, _Args...>, false>
> {
> typedef _Tp __type;
> };
>
> template<typename _Tp, bool = __has_difference_type<_Tp>::value>
> struct __ptrtr_diff_type
> {
> typedef typename _Tp::difference_type __type;
> };
>
> template<typename _Tp>
> struct __ptrtr_diff_type<_Tp, false>
> {
> typedef ptrdiff_t __type;
> };
>
> template<typename _Ptr, typename _Up>
> class __ptrtr_rebind_helper
> {
> template<typename _Ptr2, typename _Up2>
> static constexpr bool
> _S_chk(typename _Ptr2::template rebind<_Up2>*)
> { return true; }
>
> template<typename, typename>
> static constexpr bool
> _S_chk(...)
> { return false; }
>
> public:
> static const bool __value = _S_chk<_Ptr, _Up>(nullptr);
> };
>
> template<typename _Ptr, typename _Up>
> const bool __ptrtr_rebind_helper<_Ptr, _Up>::__value;
>
> template<typename _Tp, typename _Up,
> bool = __ptrtr_rebind_helper<_Tp, _Up>::__value>
> struct __ptrtr_rebind;
>
> template<typename _Tp, typename _Up>
> struct __ptrtr_rebind<_Tp, _Up, true>
> {
> typedef typename _Tp::template rebind<_Up> __type;
> };
>
> template<template<typename, typename...> class _SomePtr, typename _Up,
> typename _Tp, typename... _Args>
> struct __ptrtr_rebind<_SomePtr<_Tp, _Args...>, _Up, false>
> {
> typedef _SomePtr<_Up, _Args...> __type;
> };
>
> template<typename _Tp, typename = typename remove_cv<_Tp>::type>
> struct __ptrtr_not_void
> {
> typedef _Tp __type;
> };
>
> template<typename _Tp>
> struct __ptrtr_not_void<_Tp, void>
> {
> struct __type { };
> };
>
> template<typename _Ptr>
> class __ptrtr_pointer_to
> {
> typedef typename __ptrtr_elt_type<_Ptr>::__type __orig_type;
> typedef typename __ptrtr_not_void<__orig_type>::__type __element_type;
>
> public:
> static _Ptr pointer_to(__element_type& __e)
> { return _Ptr::pointer_to(__e); }
> };
>
>
>
>
>
> template<typename _Ptr>
> struct pointer_traits : __ptrtr_pointer_to<_Ptr>
> {
>
> typedef _Ptr pointer;
>
> typedef typename __ptrtr_elt_type<_Ptr>::__type element_type;
>
> typedef typename __ptrtr_diff_type<_Ptr>::__type difference_type;
>
> template<typename _Up>
> using rebind = typename __ptrtr_rebind<_Ptr, _Up>::__type;
> };
>
>
>
>
>
> template<typename _Tp>
> struct pointer_traits<_Tp*>
> {
>
> typedef _Tp* pointer;
>
> typedef _Tp element_type;
>
> typedef ptrdiff_t difference_type;
>
> template<typename _Up>
> using rebind = _Up*;
>
>
>
>
>
>
> static pointer
> pointer_to(typename __ptrtr_not_void<element_type>::__type& __r) noexcept
> { return std::addressof(__r); }
> };
>
>
>}
># 37 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Alloc, typename _Tp>
> class __alloctr_rebind_helper
> {
> template<typename _Alloc2, typename _Tp2>
> static constexpr bool
> _S_chk(typename _Alloc2::template rebind<_Tp2>::other*)
> { return true; }
>
> template<typename, typename>
> static constexpr bool
> _S_chk(...)
> { return false; }
>
> public:
> static const bool __value = _S_chk<_Alloc, _Tp>(nullptr);
> };
>
> template<typename _Alloc, typename _Tp>
> const bool __alloctr_rebind_helper<_Alloc, _Tp>::__value;
>
> template<typename _Alloc, typename _Tp,
> bool = __alloctr_rebind_helper<_Alloc, _Tp>::__value>
> struct __alloctr_rebind;
>
> template<typename _Alloc, typename _Tp>
> struct __alloctr_rebind<_Alloc, _Tp, true>
> {
> typedef typename _Alloc::template rebind<_Tp>::other __type;
> };
>
> template<template<typename, typename...> class _Alloc, typename _Tp,
> typename _Up, typename... _Args>
> struct __alloctr_rebind<_Alloc<_Up, _Args...>, _Tp, false>
> {
> typedef _Alloc<_Tp, _Args...> __type;
> };
>
>
>
>
>
> template<typename _Alloc>
> struct allocator_traits
> {
>
> typedef _Alloc allocator_type;
>
> typedef typename _Alloc::value_type value_type;
># 100 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
>private: template<typename _Tp> static typename _Tp::pointer _S_pointer_helper(_Tp*); static value_type* _S_pointer_helper(...); typedef decltype(_S_pointer_helper((_Alloc*)0)) __pointer; public:
>
>
>
>
>
>
> typedef __pointer pointer;
>
>private: template<typename _Tp> static typename _Tp::const_pointer _S_const_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<const value_type> _S_const_pointer_helper(...); typedef decltype(_S_const_pointer_helper((_Alloc*)0)) __const_pointer; public:
># 118 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
> typedef __const_pointer const_pointer;
>
>private: template<typename _Tp> static typename _Tp::void_pointer _S_void_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<void> _S_void_pointer_helper(...); typedef decltype(_S_void_pointer_helper((_Alloc*)0)) __void_pointer; public:
># 129 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
> typedef __void_pointer void_pointer;
>
>private: template<typename _Tp> static typename _Tp::const_void_pointer _S_const_void_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<const void> _S_const_void_pointer_helper(...); typedef decltype(_S_const_void_pointer_helper((_Alloc*)0)) __const_void_pointer; public:
># 140 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
> typedef __const_void_pointer const_void_pointer;
>
>private: template<typename _Tp> static typename _Tp::difference_type _S_difference_type_helper(_Tp*); static typename pointer_traits<pointer>::difference_type _S_difference_type_helper(...); typedef decltype(_S_difference_type_helper((_Alloc*)0)) __difference_type; public:
># 151 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
> typedef __difference_type difference_type;
>
>private: template<typename _Tp> static typename _Tp::size_type _S_size_type_helper(_Tp*); static typename make_unsigned<difference_type>::type _S_size_type_helper(...); typedef decltype(_S_size_type_helper((_Alloc*)0)) __size_type; public:
># 162 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
> typedef __size_type size_type;
>
>private: template<typename _Tp> static typename _Tp::propagate_on_container_copy_assignment _S_propagate_on_container_copy_assignment_helper(_Tp*); static false_type _S_propagate_on_container_copy_assignment_helper(...); typedef decltype(_S_propagate_on_container_copy_assignment_helper((_Alloc*)0)) __propagate_on_container_copy_assignment; public:
># 173 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
> typedef __propagate_on_container_copy_assignment
> propagate_on_container_copy_assignment;
>
>private: template<typename _Tp> static typename _Tp::propagate_on_container_move_assignment _S_propagate_on_container_move_assignment_helper(_Tp*); static false_type _S_propagate_on_container_move_assignment_helper(...); typedef decltype(_S_propagate_on_container_move_assignment_helper((_Alloc*)0)) __propagate_on_container_move_assignment; public:
># 185 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
> typedef __propagate_on_container_move_assignment
> propagate_on_container_move_assignment;
>
>private: template<typename _Tp> static typename _Tp::propagate_on_container_swap _S_propagate_on_container_swap_helper(_Tp*); static false_type _S_propagate_on_container_swap_helper(...); typedef decltype(_S_propagate_on_container_swap_helper((_Alloc*)0)) __propagate_on_container_swap; public:
># 197 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
> typedef __propagate_on_container_swap propagate_on_container_swap;
>
>
>
> template<typename _Tp>
> using rebind_alloc = typename __alloctr_rebind<_Alloc, _Tp>::__type;
> template<typename _Tp>
> using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
>
> private:
> template<typename _Alloc2>
> struct __allocate_helper
> {
> template<typename _Alloc3,
> typename = decltype(std::declval<_Alloc3*>()->allocate(
> std::declval<size_type>(),
> std::declval<const_void_pointer>()))>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
>
> typedef decltype(__test<_Alloc>(0)) type;
> static const bool value = type::value;
> };
>
> template<typename _Alloc2>
> static typename
> enable_if<__allocate_helper<_Alloc2>::value, pointer>::type
> _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint)
> { return __a.allocate(__n, __hint); }
>
> template<typename _Alloc2>
> static typename
> enable_if<!__allocate_helper<_Alloc2>::value, pointer>::type
> _S_allocate(_Alloc2& __a, size_type __n, ...)
> { return __a.allocate(__n); }
>
> template<typename _Tp, typename... _Args>
> struct __construct_helper
> {
> template<typename _Alloc2,
> typename = decltype(std::declval<_Alloc2*>()->construct(
> std::declval<_Tp*>(), std::declval<_Args>()...))>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
>
> typedef decltype(__test<_Alloc>(0)) type;
> static const bool value = type::value;
> };
>
> template<typename _Tp, typename... _Args>
> static typename
> enable_if<__construct_helper<_Tp, _Args...>::value, void>::type
> _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
> { __a.construct(__p, std::forward<_Args>(__args)...); }
>
> template<typename _Tp, typename... _Args>
> static typename
> enable_if<__and_<__not_<__construct_helper<_Tp, _Args...>>,
> is_constructible<_Tp, _Args...>>::value, void>::type
> _S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
> { ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); }
>
> template<typename _Tp>
> struct __destroy_helper
> {
> template<typename _Alloc2,
> typename = decltype(std::declval<_Alloc2*>()->destroy(
> std::declval<_Tp*>()))>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
>
> typedef decltype(__test<_Alloc>(0)) type;
> static const bool value = type::value;
> };
>
> template<typename _Tp>
> static typename enable_if<__destroy_helper<_Tp>::value, void>::type
> _S_destroy(_Alloc& __a, _Tp* __p)
> { __a.destroy(__p); }
>
> template<typename _Tp>
> static typename enable_if<!__destroy_helper<_Tp>::value, void>::type
> _S_destroy(_Alloc&, _Tp* __p)
> { __p->~_Tp(); }
>
> template<typename _Alloc2>
> struct __maxsize_helper
> {
> template<typename _Alloc3,
> typename = decltype(std::declval<_Alloc3*>()->max_size())>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
>
> typedef decltype(__test<_Alloc2>(0)) type;
> static const bool value = type::value;
> };
>
> template<typename _Alloc2>
> static typename
> enable_if<__maxsize_helper<_Alloc2>::value, size_type>::type
> _S_max_size(_Alloc2& __a)
> { return __a.max_size(); }
>
> template<typename _Alloc2>
> static typename
> enable_if<!__maxsize_helper<_Alloc2>::value, size_type>::type
> _S_max_size(_Alloc2&)
> { return __gnu_cxx::__numeric_traits<size_type>::__max; }
>
> template<typename _Alloc2>
> struct __select_helper
> {
> template<typename _Alloc3, typename
> = decltype(std::declval<_Alloc3*>()
> ->select_on_container_copy_construction())>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
>
> typedef decltype(__test<_Alloc2>(0)) type;
> static const bool value = type::value;
> };
> template<typename _Alloc2>
> static typename
> enable_if<__select_helper<_Alloc2>::value, _Alloc2>::type
> _S_select(_Alloc2& __a)
> { return __a.select_on_container_copy_construction(); }
>
> template<typename _Alloc2>
> static typename
> enable_if<!__select_helper<_Alloc2>::value, _Alloc2>::type
> _S_select(_Alloc2& __a)
> { return __a; }
>
> public:
># 349 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
> static pointer
> allocate(_Alloc& __a, size_type __n)
> { return __a.allocate(__n); }
># 364 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
> static pointer
> allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
> { return _S_allocate(__a, __n, __hint); }
># 376 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
> static void deallocate(_Alloc& __a, pointer __p, size_type __n)
> { __a.deallocate(__p, __n); }
># 390 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
> template<typename _Tp, typename... _Args>
> static auto construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
> -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
> { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
># 403 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
> template <class _Tp>
> static void destroy(_Alloc& __a, _Tp* __p)
> { _S_destroy(__a, __p); }
># 415 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
> static size_type max_size(const _Alloc& __a)
> { return _S_max_size(__a); }
># 426 "/usr/include/c++/4.8.2/bits/alloc_traits.h" 3
> static _Alloc
> select_on_container_copy_construction(const _Alloc& __rhs)
> { return _S_select(__rhs); }
> };
>
> template<typename _Alloc>
> template<typename _Alloc2>
> const bool allocator_traits<_Alloc>::__allocate_helper<_Alloc2>::value;
>
> template<typename _Alloc>
> template<typename _Tp, typename... _Args>
> const bool
> allocator_traits<_Alloc>::__construct_helper<_Tp, _Args...>::value;
>
> template<typename _Alloc>
> template<typename _Tp>
> const bool allocator_traits<_Alloc>::__destroy_helper<_Tp>::value;
>
> template<typename _Alloc>
> template<typename _Alloc2>
> const bool allocator_traits<_Alloc>::__maxsize_helper<_Alloc2>::value;
>
> template<typename _Alloc>
> template<typename _Alloc2>
> const bool allocator_traits<_Alloc>::__select_helper<_Alloc2>::value;
>
> template<typename _Alloc>
> inline void
> __do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
> { __one = __two; }
>
> template<typename _Alloc>
> inline void
> __do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
> { }
>
> template<typename _Alloc>
> inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
> {
> typedef allocator_traits<_Alloc> __traits;
> typedef typename __traits::propagate_on_container_copy_assignment __pocca;
> __do_alloc_on_copy(__one, __two, __pocca());
> }
>
> template<typename _Alloc>
> inline _Alloc __alloc_on_copy(const _Alloc& __a)
> {
> typedef allocator_traits<_Alloc> __traits;
> return __traits::select_on_container_copy_construction(__a);
> }
>
> template<typename _Alloc>
> inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
> { __one = std::move(__two); }
>
> template<typename _Alloc>
> inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
> { }
>
> template<typename _Alloc>
> inline void __alloc_on_move(_Alloc& __one, _Alloc& __two)
> {
> typedef allocator_traits<_Alloc> __traits;
> typedef typename __traits::propagate_on_container_move_assignment __pocma;
> __do_alloc_on_move(__one, __two, __pocma());
> }
>
> template<typename _Alloc>
> inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
> {
> using std::swap;
> swap(__one, __two);
> }
>
> template<typename _Alloc>
> inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
> { }
>
> template<typename _Alloc>
> inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two)
> {
> typedef allocator_traits<_Alloc> __traits;
> typedef typename __traits::propagate_on_container_swap __pocs;
> __do_alloc_on_swap(__one, __two, __pocs());
> }
>
> template<typename _Alloc>
> class __is_copy_insertable_impl
> {
> typedef allocator_traits<_Alloc> _Traits;
>
> template<typename _Up, typename
> = decltype(_Traits::construct(std::declval<_Alloc&>(),
> std::declval<_Up*>(),
> std::declval<const _Up&>()))>
> static true_type
> _M_select(int);
>
> template<typename _Up>
> static false_type
> _M_select(...);
>
> public:
> typedef decltype(_M_select<typename _Alloc::value_type>(0)) type;
> };
>
>
> template<typename _Alloc>
> struct __is_copy_insertable
> : __is_copy_insertable_impl<_Alloc>::type
> { };
>
>
> template<typename _Tp>
> struct __is_copy_insertable<allocator<_Tp>>
> : is_copy_constructible<_Tp>
> { };
>
>
> template<bool> struct __allow_copy_cons { };
>
>
> template<>
> struct __allow_copy_cons<false>
> {
> __allow_copy_cons() = default;
> __allow_copy_cons(const __allow_copy_cons&) = delete;
> __allow_copy_cons(__allow_copy_cons&&) = default;
> __allow_copy_cons& operator=(const __allow_copy_cons&) = default;
> __allow_copy_cons& operator=(__allow_copy_cons&&) = default;
> };
>
> template<typename _Alloc>
> using __check_copy_constructible
> = __allow_copy_cons<__is_copy_insertable<_Alloc>::value>;
>
>
>}
># 37 "/usr/include/c++/4.8.2/ext/alloc_traits.h" 2 3
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _Alloc>
> struct __allocator_always_compares_equal
> { static const bool value = false; };
>
> template<typename _Alloc>
> const bool __allocator_always_compares_equal<_Alloc>::value;
>
> template<typename _Tp>
> struct __allocator_always_compares_equal<std::allocator<_Tp>>
> { static const bool value = true; };
>
> template<typename _Tp>
> const bool __allocator_always_compares_equal<std::allocator<_Tp>>::value;
>
> template<typename, typename> struct array_allocator;
>
> template<typename _Tp, typename _Array>
> struct __allocator_always_compares_equal<array_allocator<_Tp, _Array>>
> { static const bool value = true; };
>
> template<typename _Tp, typename _Array>
> const bool
> __allocator_always_compares_equal<array_allocator<_Tp, _Array>>::value;
>
> template<typename> struct bitmap_allocator;
>
> template<typename _Tp>
> struct __allocator_always_compares_equal<bitmap_allocator<_Tp>>
> { static const bool value = true; };
>
> template<typename _Tp>
> const bool __allocator_always_compares_equal<bitmap_allocator<_Tp>>::value;
>
> template<typename> struct malloc_allocator;
>
> template<typename _Tp>
> struct __allocator_always_compares_equal<malloc_allocator<_Tp>>
> { static const bool value = true; };
>
> template<typename _Tp>
> const bool __allocator_always_compares_equal<malloc_allocator<_Tp>>::value;
>
> template<typename> struct mt_allocator;
>
> template<typename _Tp>
> struct __allocator_always_compares_equal<mt_allocator<_Tp>>
> { static const bool value = true; };
>
> template<typename _Tp>
> const bool __allocator_always_compares_equal<mt_allocator<_Tp>>::value;
>
> template<typename> struct new_allocator;
>
> template<typename _Tp>
> struct __allocator_always_compares_equal<new_allocator<_Tp>>
> { static const bool value = true; };
>
> template<typename _Tp>
> const bool __allocator_always_compares_equal<new_allocator<_Tp>>::value;
>
> template<typename> struct pool_allocator;
>
> template<typename _Tp>
> struct __allocator_always_compares_equal<pool_allocator<_Tp>>
> { static const bool value = true; };
>
> template<typename _Tp>
> const bool __allocator_always_compares_equal<pool_allocator<_Tp>>::value;
>
>
>
>
>
>
>template<typename _Alloc>
> struct __alloc_traits
>
> : std::allocator_traits<_Alloc>
>
> {
> typedef _Alloc allocator_type;
>
> typedef std::allocator_traits<_Alloc> _Base_type;
> typedef typename _Base_type::value_type value_type;
> typedef typename _Base_type::pointer pointer;
> typedef typename _Base_type::const_pointer const_pointer;
> typedef typename _Base_type::size_type size_type;
> typedef typename _Base_type::difference_type difference_type;
>
> typedef value_type& reference;
> typedef const value_type& const_reference;
> using _Base_type::allocate;
> using _Base_type::deallocate;
> using _Base_type::construct;
> using _Base_type::destroy;
> using _Base_type::max_size;
>
> private:
> template<typename _Ptr>
> struct __is_custom_pointer
> : std::integral_constant<bool, std::is_same<pointer, _Ptr>::value
> && !std::is_pointer<_Ptr>::value>
> { };
>
> public:
>
> template<typename _Ptr, typename... _Args>
> static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
> construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
> {
> _Base_type::construct(__a, std::addressof(*__p),
> std::forward<_Args>(__args)...);
> }
>
>
> template<typename _Ptr>
> static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
> destroy(_Alloc& __a, _Ptr __p)
> { _Base_type::destroy(__a, std::addressof(*__p)); }
>
> static _Alloc _S_select_on_copy(const _Alloc& __a)
> { return _Base_type::select_on_container_copy_construction(__a); }
>
> static void _S_on_swap(_Alloc& __a, _Alloc& __b)
> { std::__alloc_on_swap(__a, __b); }
>
> static constexpr bool _S_propagate_on_copy_assign()
> { return _Base_type::propagate_on_container_copy_assignment::value; }
>
> static constexpr bool _S_propagate_on_move_assign()
> { return _Base_type::propagate_on_container_move_assignment::value; }
>
> static constexpr bool _S_propagate_on_swap()
> { return _Base_type::propagate_on_container_swap::value; }
>
> static constexpr bool _S_always_equal()
> { return __allocator_always_compares_equal<_Alloc>::value; }
>
> static constexpr bool _S_nothrow_move()
> { return _S_propagate_on_move_assign() || _S_always_equal(); }
>
> static constexpr bool _S_nothrow_swap()
> {
> using std::swap;
> return !_S_propagate_on_swap()
> || noexcept(swap(std::declval<_Alloc&>(), std::declval<_Alloc&>()));
> }
>
> template<typename _Tp>
> struct rebind
> { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
># 237 "/usr/include/c++/4.8.2/ext/alloc_traits.h" 3
> };
>
>
>}
># 62 "/usr/include/c++/4.8.2/bits/stl_construct.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> template<typename _T1, typename... _Args>
> inline void
> _Construct(_T1* __p, _Args&&... __args)
> { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
># 90 "/usr/include/c++/4.8.2/bits/stl_construct.h" 3
> template<typename _Tp>
> inline void
> _Destroy(_Tp* __pointer)
> { __pointer->~_Tp(); }
>
> template<bool>
> struct _Destroy_aux
> {
> template<typename _ForwardIterator>
> static void
> __destroy(_ForwardIterator __first, _ForwardIterator __last)
> {
> for (; __first != __last; ++__first)
> std::_Destroy(std::__addressof(*__first));
> }
> };
>
> template<>
> struct _Destroy_aux<true>
> {
> template<typename _ForwardIterator>
> static void
> __destroy(_ForwardIterator, _ForwardIterator) { }
> };
>
>
>
>
>
>
> template<typename _ForwardIterator>
> inline void
> _Destroy(_ForwardIterator __first, _ForwardIterator __last)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _Value_type;
> std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
> __destroy(__first, __last);
> }
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Allocator>
> void
> _Destroy(_ForwardIterator __first, _ForwardIterator __last,
> _Allocator& __alloc)
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __first != __last; ++__first)
> __traits::destroy(__alloc, std::__addressof(*__first));
> }
>
> template<typename _ForwardIterator, typename _Tp>
> inline void
> _Destroy(_ForwardIterator __first, _ForwardIterator __last,
> allocator<_Tp>&)
> {
> _Destroy(__first, __last);
> }
>
>
>}
># 63 "/usr/include/c++/4.8.2/vector" 2 3
># 1 "/usr/include/c++/4.8.2/bits/stl_uninitialized.h" 1 3
># 59 "/usr/include/c++/4.8.2/bits/stl_uninitialized.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<bool _TrivialValueTypes>
> struct __uninitialized_copy
> {
> template<typename _InputIterator, typename _ForwardIterator>
> static _ForwardIterator
> __uninit_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result)
> {
> _ForwardIterator __cur = __result;
> try
> {
> for (; __first != __last; ++__first, ++__cur)
> std::_Construct(std::__addressof(*__cur), *__first);
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__result, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_copy<true>
> {
> template<typename _InputIterator, typename _ForwardIterator>
> static _ForwardIterator
> __uninit_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result)
> { return std::copy(__first, __last, __result); }
> };
># 105 "/usr/include/c++/4.8.2/bits/stl_uninitialized.h" 3
> template<typename _InputIterator, typename _ForwardIterator>
> inline _ForwardIterator
> uninitialized_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result)
> {
> typedef typename iterator_traits<_InputIterator>::value_type
> _ValueType1;
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType2;
>
> return std::__uninitialized_copy<(__is_trivial(_ValueType1)
> && __is_trivial(_ValueType2))>::
> __uninit_copy(__first, __last, __result);
> }
>
>
> template<bool _TrivialValueType>
> struct __uninitialized_fill
> {
> template<typename _ForwardIterator, typename _Tp>
> static void
> __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __cur != __last; ++__cur)
> std::_Construct(std::__addressof(*__cur), __x);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_fill<true>
> {
> template<typename _ForwardIterator, typename _Tp>
> static void
> __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x)
> { std::fill(__first, __last, __x); }
> };
># 162 "/usr/include/c++/4.8.2/bits/stl_uninitialized.h" 3
> template<typename _ForwardIterator, typename _Tp>
> inline void
> uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> std::__uninitialized_fill<__is_trivial(_ValueType)>::
> __uninit_fill(__first, __last, __x);
> }
>
>
> template<bool _TrivialValueType>
> struct __uninitialized_fill_n
> {
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> static void
> __uninit_fill_n(_ForwardIterator __first, _Size __n,
> const _Tp& __x)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __n > 0; --__n, ++__cur)
> std::_Construct(std::__addressof(*__cur), __x);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_fill_n<true>
> {
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> static void
> __uninit_fill_n(_ForwardIterator __first, _Size __n,
> const _Tp& __x)
> { std::fill_n(__first, __n, __x); }
> };
># 216 "/usr/include/c++/4.8.2/bits/stl_uninitialized.h" 3
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> inline void
> uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> std::__uninitialized_fill_n<__is_trivial(_ValueType)>::
> __uninit_fill_n(__first, __n, __x);
> }
>
>
>
>
>
>
>
> template<typename _InputIterator, typename _ForwardIterator,
> typename _Allocator>
> _ForwardIterator
> __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result, _Allocator& __alloc)
> {
> _ForwardIterator __cur = __result;
> try
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __first != __last; ++__first, ++__cur)
> __traits::construct(__alloc, std::__addressof(*__cur), *__first);
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__result, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
> inline _ForwardIterator
> __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result, allocator<_Tp>&)
> { return std::uninitialized_copy(__first, __last, __result); }
>
> template<typename _InputIterator, typename _ForwardIterator,
> typename _Allocator>
> inline _ForwardIterator
> __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result, _Allocator& __alloc)
> {
> return std::__uninitialized_copy_a(std::make_move_iterator(__first),
> std::make_move_iterator(__last),
> __result, __alloc);
> }
>
> template<typename _InputIterator, typename _ForwardIterator,
> typename _Allocator>
> inline _ForwardIterator
> __uninitialized_move_if_noexcept_a(_InputIterator __first,
> _InputIterator __last,
> _ForwardIterator __result,
> _Allocator& __alloc)
> {
> return std::__uninitialized_copy_a
> (std::__make_move_if_noexcept_iterator(__first),
> std::__make_move_if_noexcept_iterator(__last), __result, __alloc);
> }
>
> template<typename _ForwardIterator, typename _Tp, typename _Allocator>
> void
> __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x, _Allocator& __alloc)
> {
> _ForwardIterator __cur = __first;
> try
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __cur != __last; ++__cur)
> __traits::construct(__alloc, std::__addressof(*__cur), __x);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _ForwardIterator, typename _Tp, typename _Tp2>
> inline void
> __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x, allocator<_Tp2>&)
> { std::uninitialized_fill(__first, __last, __x); }
>
> template<typename _ForwardIterator, typename _Size, typename _Tp,
> typename _Allocator>
> void
> __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
> const _Tp& __x, _Allocator& __alloc)
> {
> _ForwardIterator __cur = __first;
> try
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __n > 0; --__n, ++__cur)
> __traits::construct(__alloc, std::__addressof(*__cur), __x);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _ForwardIterator, typename _Size, typename _Tp,
> typename _Tp2>
> inline void
> __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
> const _Tp& __x, allocator<_Tp2>&)
> { std::uninitialized_fill_n(__first, __n, __x); }
># 346 "/usr/include/c++/4.8.2/bits/stl_uninitialized.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _ForwardIterator, typename _Allocator>
> inline _ForwardIterator
> __uninitialized_copy_move(_InputIterator1 __first1,
> _InputIterator1 __last1,
> _InputIterator2 __first2,
> _InputIterator2 __last2,
> _ForwardIterator __result,
> _Allocator& __alloc)
> {
> _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
> __result,
> __alloc);
> try
> {
> return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
> }
> catch(...)
> {
> std::_Destroy(__result, __mid, __alloc);
> throw;
> }
> }
>
>
>
>
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _ForwardIterator, typename _Allocator>
> inline _ForwardIterator
> __uninitialized_move_copy(_InputIterator1 __first1,
> _InputIterator1 __last1,
> _InputIterator2 __first2,
> _InputIterator2 __last2,
> _ForwardIterator __result,
> _Allocator& __alloc)
> {
> _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
> __result,
> __alloc);
> try
> {
> return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
> }
> catch(...)
> {
> std::_Destroy(__result, __mid, __alloc);
> throw;
> }
> }
>
>
>
>
> template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
> typename _Allocator>
> inline _ForwardIterator
> __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
> const _Tp& __x, _InputIterator __first,
> _InputIterator __last, _Allocator& __alloc)
> {
> std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
> try
> {
> return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
> }
> catch(...)
> {
> std::_Destroy(__result, __mid, __alloc);
> throw;
> }
> }
>
>
>
>
> template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
> typename _Allocator>
> inline void
> __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
> _ForwardIterator __first2,
> _ForwardIterator __last2, const _Tp& __x,
> _Allocator& __alloc)
> {
> _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
> __first2,
> __alloc);
> try
> {
> std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
> }
> catch(...)
> {
> std::_Destroy(__first2, __mid2, __alloc);
> throw;
> }
> }
>
>
>
>
>
> template<bool _TrivialValueType>
> struct __uninitialized_default_1
> {
> template<typename _ForwardIterator>
> static void
> __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __cur != __last; ++__cur)
> std::_Construct(std::__addressof(*__cur));
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_default_1<true>
> {
> template<typename _ForwardIterator>
> static void
> __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> std::fill(__first, __last, _ValueType());
> }
> };
>
> template<bool _TrivialValueType>
> struct __uninitialized_default_n_1
> {
> template<typename _ForwardIterator, typename _Size>
> static void
> __uninit_default_n(_ForwardIterator __first, _Size __n)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __n > 0; --__n, ++__cur)
> std::_Construct(std::__addressof(*__cur));
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_default_n_1<true>
> {
> template<typename _ForwardIterator, typename _Size>
> static void
> __uninit_default_n(_ForwardIterator __first, _Size __n)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> std::fill_n(__first, __n, _ValueType());
> }
> };
>
>
>
>
> template<typename _ForwardIterator>
> inline void
> __uninitialized_default(_ForwardIterator __first,
> _ForwardIterator __last)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> std::__uninitialized_default_1<__is_trivial(_ValueType)>::
> __uninit_default(__first, __last);
> }
>
>
>
> template<typename _ForwardIterator, typename _Size>
> inline void
> __uninitialized_default_n(_ForwardIterator __first, _Size __n)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> std::__uninitialized_default_n_1<__is_trivial(_ValueType)>::
> __uninit_default_n(__first, __n);
> }
>
>
>
>
>
> template<typename _ForwardIterator, typename _Allocator>
> void
> __uninitialized_default_a(_ForwardIterator __first,
> _ForwardIterator __last,
> _Allocator& __alloc)
> {
> _ForwardIterator __cur = __first;
> try
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __cur != __last; ++__cur)
> __traits::construct(__alloc, std::__addressof(*__cur));
> }
> catch(...)
> {
> std::_Destroy(__first, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _ForwardIterator, typename _Tp>
> inline void
> __uninitialized_default_a(_ForwardIterator __first,
> _ForwardIterator __last,
> allocator<_Tp>&)
> { std::__uninitialized_default(__first, __last); }
>
>
>
>
>
> template<typename _ForwardIterator, typename _Size, typename _Allocator>
> void
> __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
> _Allocator& __alloc)
> {
> _ForwardIterator __cur = __first;
> try
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __n > 0; --__n, ++__cur)
> __traits::construct(__alloc, std::__addressof(*__cur));
> }
> catch(...)
> {
> std::_Destroy(__first, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> inline void
> __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
> allocator<_Tp>&)
> { std::__uninitialized_default_n(__first, __n); }
>
>
> template<typename _InputIterator, typename _Size,
> typename _ForwardIterator>
> _ForwardIterator
> __uninitialized_copy_n(_InputIterator __first, _Size __n,
> _ForwardIterator __result, input_iterator_tag)
> {
> _ForwardIterator __cur = __result;
> try
> {
> for (; __n > 0; --__n, ++__first, ++__cur)
> std::_Construct(std::__addressof(*__cur), *__first);
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__result, __cur);
> throw;
> }
> }
>
> template<typename _RandomAccessIterator, typename _Size,
> typename _ForwardIterator>
> inline _ForwardIterator
> __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
> _ForwardIterator __result,
> random_access_iterator_tag)
> { return std::uninitialized_copy(__first, __first + __n, __result); }
># 645 "/usr/include/c++/4.8.2/bits/stl_uninitialized.h" 3
> template<typename _InputIterator, typename _Size, typename _ForwardIterator>
> inline _ForwardIterator
> uninitialized_copy_n(_InputIterator __first, _Size __n,
> _ForwardIterator __result)
> { return std::__uninitialized_copy_n(__first, __n, __result,
> std::__iterator_category(__first)); }
>
>
>
>}
># 64 "/usr/include/c++/4.8.2/vector" 2 3
># 1 "/usr/include/c++/4.8.2/bits/stl_vector.h" 1 3
># 66 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _Tp, typename _Alloc>
> struct _Vector_base
> {
> typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
> rebind<_Tp>::other _Tp_alloc_type;
> typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
> pointer;
>
> struct _Vector_impl
> : public _Tp_alloc_type
> {
> pointer _M_start;
> pointer _M_finish;
> pointer _M_end_of_storage;
>
> _Vector_impl()
> : _Tp_alloc_type(), _M_start(0), _M_finish(0), _M_end_of_storage(0)
> { }
>
> _Vector_impl(_Tp_alloc_type const& __a)
> : _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
> { }
>
>
> _Vector_impl(_Tp_alloc_type&& __a)
> : _Tp_alloc_type(std::move(__a)),
> _M_start(0), _M_finish(0), _M_end_of_storage(0)
> { }
>
>
> void _M_swap_data(_Vector_impl& __x)
> {
> std::swap(_M_start, __x._M_start);
> std::swap(_M_finish, __x._M_finish);
> std::swap(_M_end_of_storage, __x._M_end_of_storage);
> }
> };
>
> public:
> typedef _Alloc allocator_type;
>
> _Tp_alloc_type&
> _M_get_Tp_allocator() noexcept
> { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
>
> const _Tp_alloc_type&
> _M_get_Tp_allocator() const noexcept
> { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
>
> allocator_type
> get_allocator() const noexcept
> { return allocator_type(_M_get_Tp_allocator()); }
>
> _Vector_base()
> : _M_impl() { }
>
> _Vector_base(const allocator_type& __a)
> : _M_impl(__a) { }
>
> _Vector_base(size_t __n)
> : _M_impl()
> { _M_create_storage(__n); }
>
> _Vector_base(size_t __n, const allocator_type& __a)
> : _M_impl(__a)
> { _M_create_storage(__n); }
>
>
> _Vector_base(_Tp_alloc_type&& __a)
> : _M_impl(std::move(__a)) { }
>
> _Vector_base(_Vector_base&& __x)
> : _M_impl(std::move(__x._M_get_Tp_allocator()))
> { this->_M_impl._M_swap_data(__x._M_impl); }
>
> _Vector_base(_Vector_base&& __x, const allocator_type& __a)
> : _M_impl(__a)
> {
> if (__x.get_allocator() == __a)
> this->_M_impl._M_swap_data(__x._M_impl);
> else
> {
> size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
> _M_create_storage(__n);
> }
> }
>
>
> ~_Vector_base()
> { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start); }
>
> public:
> _Vector_impl _M_impl;
>
> pointer
> _M_allocate(size_t __n)
> { return __n != 0 ? _M_impl.allocate(__n) : 0; }
>
> void
> _M_deallocate(pointer __p, size_t __n)
> {
> if (__p)
> _M_impl.deallocate(__p, __n);
> }
>
> private:
> void
> _M_create_storage(size_t __n)
> {
> this->_M_impl._M_start = this->_M_allocate(__n);
> this->_M_impl._M_finish = this->_M_impl._M_start;
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
> }
> };
># 209 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
> class vector : protected _Vector_base<_Tp, _Alloc>
> {
>
> typedef typename _Alloc::value_type _Alloc_value_type;
> 
> 
>
> typedef _Vector_base<_Tp, _Alloc> _Base;
> typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
> typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
>
> public:
> typedef _Tp value_type;
> typedef typename _Base::pointer pointer;
> typedef typename _Alloc_traits::const_pointer const_pointer;
> typedef typename _Alloc_traits::reference reference;
> typedef typename _Alloc_traits::const_reference const_reference;
> typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
> typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
> const_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Alloc allocator_type;
>
> protected:
> using _Base::_M_allocate;
> using _Base::_M_deallocate;
> using _Base::_M_impl;
> using _Base::_M_get_Tp_allocator;
>
> public:
>
>
>
>
>
> vector()
> : _Base() { }
>
>
>
>
>
> explicit
> vector(const allocator_type& __a)
> : _Base(__a) { }
># 268 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> explicit
> vector(size_type __n, const allocator_type& __a = allocator_type())
> : _Base(__n, __a)
> { _M_default_initialize(__n); }
># 281 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> vector(size_type __n, const value_type& __value,
> const allocator_type& __a = allocator_type())
> : _Base(__n, __a)
> { _M_fill_initialize(__n, __value); }
># 310 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> vector(const vector& __x)
> : _Base(__x.size(),
> _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
> { this->_M_impl._M_finish =
> std::__uninitialized_copy_a(__x.begin(), __x.end(),
> this->_M_impl._M_start,
> _M_get_Tp_allocator());
> }
># 327 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> vector(vector&& __x) noexcept
> : _Base(std::move(__x)) { }
>
>
> vector(const vector& __x, const allocator_type& __a)
> : _Base(__x.size(), __a)
> { this->_M_impl._M_finish =
> std::__uninitialized_copy_a(__x.begin(), __x.end(),
> this->_M_impl._M_start,
> _M_get_Tp_allocator());
> }
>
>
> vector(vector&& __rv, const allocator_type& __m)
> : _Base(std::move(__rv), __m)
> {
> if (__rv.get_allocator() != __m)
> {
> this->_M_impl._M_finish =
> std::__uninitialized_move_a(__rv.begin(), __rv.end(),
> this->_M_impl._M_start,
> _M_get_Tp_allocator());
> __rv.clear();
> }
> }
># 364 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> vector(initializer_list<value_type> __l,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> {
> _M_range_initialize(__l.begin(), __l.end(),
> random_access_iterator_tag());
> }
># 390 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> vector(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> { _M_initialize_dispatch(__first, __last, __false_type()); }
># 414 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> ~vector() noexcept
> { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator()); }
># 426 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> vector&
> operator=(const vector& __x);
># 438 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> vector&
> operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
> {
> constexpr bool __move_storage =
> _Alloc_traits::_S_propagate_on_move_assign()
> || _Alloc_traits::_S_always_equal();
> _M_move_assign(std::move(__x),
> integral_constant<bool, __move_storage>());
> return *this;
> }
># 460 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> vector&
> operator=(initializer_list<value_type> __l)
> {
> this->assign(__l.begin(), __l.end());
> return *this;
> }
># 478 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> void
> assign(size_type __n, const value_type& __val)
> { _M_fill_assign(__n, __val); }
># 495 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> void
> assign(_InputIterator __first, _InputIterator __last)
> { _M_assign_dispatch(__first, __last, __false_type()); }
># 523 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> void
> assign(initializer_list<value_type> __l)
> { this->assign(__l.begin(), __l.end()); }
>
>
>
> using _Base::get_allocator;
>
>
>
>
>
>
>
> iterator
> begin() noexcept
> { return iterator(this->_M_impl._M_start); }
>
>
>
>
>
>
> const_iterator
> begin() const noexcept
> { return const_iterator(this->_M_impl._M_start); }
>
>
>
>
>
>
> iterator
> end() noexcept
> { return iterator(this->_M_impl._M_finish); }
>
>
>
>
>
>
> const_iterator
> end() const noexcept
> { return const_iterator(this->_M_impl._M_finish); }
>
>
>
>
>
>
> reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(end()); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
>
>
>
>
>
> reverse_iterator
> rend() noexcept
> { return reverse_iterator(begin()); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
>
>
>
>
>
> const_iterator
> cbegin() const noexcept
> { return const_iterator(this->_M_impl._M_start); }
>
>
>
>
>
>
> const_iterator
> cend() const noexcept
> { return const_iterator(this->_M_impl._M_finish); }
>
>
>
>
>
>
> const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
>
>
>
>
>
> const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
>
>
> size_type
> size() const noexcept
> { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
>
>
> size_type
> max_size() const noexcept
> { return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
># 663 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> void
> resize(size_type __new_size)
> {
> if (__new_size > size())
> _M_default_append(__new_size - size());
> else if (__new_size < size())
> _M_erase_at_end(this->_M_impl._M_start + __new_size);
> }
># 683 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> void
> resize(size_type __new_size, const value_type& __x)
> {
> if (__new_size > size())
> insert(end(), __new_size - size(), __x);
> else if (__new_size < size())
> _M_erase_at_end(this->_M_impl._M_start + __new_size);
> }
># 715 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> void
> shrink_to_fit()
> { _M_shrink_to_fit(); }
>
>
>
>
>
>
> size_type
> capacity() const noexcept
> { return size_type(this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start); }
>
>
>
>
>
> bool
> empty() const noexcept
> { return begin() == end(); }
># 754 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> void
> reserve(size_type __n);
># 769 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> reference
> operator[](size_type __n)
> { return *(this->_M_impl._M_start + __n); }
># 784 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> const_reference
> operator[](size_type __n) const
> { return *(this->_M_impl._M_start + __n); }
>
> protected:
>
> void
> _M_range_check(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range(("vector::_M_range_check"));
> }
>
> public:
># 809 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> reference
> at(size_type __n)
> {
> _M_range_check(__n);
> return (*this)[__n];
> }
># 827 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> const_reference
> at(size_type __n) const
> {
> _M_range_check(__n);
> return (*this)[__n];
> }
>
>
>
>
>
> reference
> front()
> { return *begin(); }
>
>
>
>
>
> const_reference
> front() const
> { return *begin(); }
>
>
>
>
>
> reference
> back()
> { return *(end() - 1); }
>
>
>
>
>
> const_reference
> back() const
> { return *(end() - 1); }
># 874 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> _Tp*
>
>
>
> data() noexcept
> { return std::__addressof(front()); }
>
>
> const _Tp*
>
>
>
> data() const noexcept
> { return std::__addressof(front()); }
># 900 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> void
> push_back(const value_type& __x)
> {
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
> {
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
> __x);
> ++this->_M_impl._M_finish;
> }
> else
>
> _M_emplace_back_aux(__x);
>
>
>
> }
>
>
> void
> push_back(value_type&& __x)
> { emplace_back(std::move(__x)); }
>
> template<typename... _Args>
> void
> emplace_back(_Args&&... __args);
># 936 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> void
> pop_back()
> {
> --this->_M_impl._M_finish;
> _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
> }
># 956 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> template<typename... _Args>
> iterator
> emplace(iterator __position, _Args&&... __args);
># 972 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> iterator
> insert(iterator __position, const value_type& __x);
># 987 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> iterator
> insert(iterator __position, value_type&& __x)
> { return emplace(__position, std::move(__x)); }
># 1004 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> void
> insert(iterator __position, initializer_list<value_type> __l)
> { this->insert(__position, __l.begin(), __l.end()); }
># 1022 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> void
> insert(iterator __position, size_type __n, const value_type& __x)
> { _M_fill_insert(__position, __n, __x); }
># 1041 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> void
> insert(iterator __position, _InputIterator __first,
> _InputIterator __last)
> { _M_insert_dispatch(__position, __first, __last, __false_type()); }
># 1074 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> iterator
> erase(iterator __position);
># 1095 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> iterator
> erase(iterator __first, iterator __last);
># 1107 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> void
> swap(vector& __x)
>
> noexcept(_Alloc_traits::_S_nothrow_swap())
>
> {
> this->_M_impl._M_swap_data(__x._M_impl);
> _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
> __x._M_get_Tp_allocator());
> }
>
>
>
>
>
>
>
> void
> clear() noexcept
> { _M_erase_at_end(this->_M_impl._M_start); }
>
> protected:
>
>
>
>
> template<typename _ForwardIterator>
> pointer
> _M_allocate_and_copy(size_type __n,
> _ForwardIterator __first, _ForwardIterator __last)
> {
> pointer __result = this->_M_allocate(__n);
> try
> {
> std::__uninitialized_copy_a(__first, __last, __result,
> _M_get_Tp_allocator());
> return __result;
> }
> catch(...)
> {
> _M_deallocate(__result, __n);
> throw;
> }
> }
># 1159 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> template<typename _Integer>
> void
> _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
> {
> this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
> this->_M_impl._M_end_of_storage =
> this->_M_impl._M_start + static_cast<size_type>(__n);
> _M_fill_initialize(static_cast<size_type>(__n), __value);
> }
>
>
> template<typename _InputIterator>
> void
> _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_range_initialize(__first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_range_initialize(_InputIterator __first,
> _InputIterator __last, std::input_iterator_tag)
> {
> for (; __first != __last; ++__first)
>
> emplace_back(*__first);
>
>
>
> }
>
>
> template<typename _ForwardIterator>
> void
> _M_range_initialize(_ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag)
> {
> const size_type __n = std::distance(__first, __last);
> this->_M_impl._M_start = this->_M_allocate(__n);
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
> this->_M_impl._M_finish =
> std::__uninitialized_copy_a(__first, __last,
> this->_M_impl._M_start,
> _M_get_Tp_allocator());
> }
>
>
>
> void
> _M_fill_initialize(size_type __n, const value_type& __value)
> {
> std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
> }
>
>
>
> void
> _M_default_initialize(size_type __n)
> {
> std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
> }
># 1237 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> template<typename _Integer>
> void
> _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> { _M_fill_assign(__n, __val); }
>
>
> template<typename _InputIterator>
> void
> _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_assign_aux(__first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag);
>
>
>
> void
> _M_fill_assign(size_type __n, const value_type& __val);
># 1277 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> template<typename _Integer>
> void
> _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
> __true_type)
> { _M_fill_insert(__pos, __n, __val); }
>
>
> template<typename _InputIterator>
> void
> _M_insert_dispatch(iterator __pos, _InputIterator __first,
> _InputIterator __last, __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_range_insert(__pos, __first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_range_insert(iterator __pos, _InputIterator __first,
> _InputIterator __last, std::input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_range_insert(iterator __pos, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag);
>
>
>
> void
> _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
>
>
>
> void
> _M_default_append(size_type __n);
>
> bool
> _M_shrink_to_fit();
>
>
>
>
>
>
>
> template<typename... _Args>
> void
> _M_insert_aux(iterator __position, _Args&&... __args);
>
> template<typename... _Args>
> void
> _M_emplace_back_aux(_Args&&... __args);
>
>
>
> size_type
> _M_check_len(size_type __n, const char* __s) const
> {
> if (max_size() - size() < __n)
> __throw_length_error((__s));
>
> const size_type __len = size() + std::max(size(), __n);
> return (__len < size() || __len > max_size()) ? max_size() : __len;
> }
>
>
>
>
>
> void
> _M_erase_at_end(pointer __pos)
> {
> std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
> this->_M_impl._M_finish = __pos;
> }
>
>
> private:
>
>
>
> void
> _M_move_assign(vector&& __x, std::true_type) noexcept
> {
> const vector __tmp(std::move(*this));
> this->_M_impl._M_swap_data(__x._M_impl);
> if (_Alloc_traits::_S_propagate_on_move_assign())
> std::__alloc_on_move(_M_get_Tp_allocator(),
> __x._M_get_Tp_allocator());
> }
>
>
>
> void
> _M_move_assign(vector&& __x, std::false_type)
> {
> if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
> _M_move_assign(std::move(__x), std::true_type());
> else
> {
>
>
> this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
> std::__make_move_if_noexcept_iterator(__x.end()));
> __x.clear();
> }
> }
>
> };
># 1401 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return (__x.size() == __y.size()
> && std::equal(__x.begin(), __x.end(), __y.begin())); }
># 1418 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return std::lexicographical_compare(__x.begin(), __x.end(),
> __y.begin(), __y.end()); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return __y < __x; }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline void
> swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
> { __x.swap(__y); }
>
>
>}
># 65 "/usr/include/c++/4.8.2/vector" 2 3
># 1 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 1 3
># 63 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> typedef unsigned long _Bit_type;
> enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };
>
> struct _Bit_reference
> {
> _Bit_type * _M_p;
> _Bit_type _M_mask;
>
> _Bit_reference(_Bit_type * __x, _Bit_type __y)
> : _M_p(__x), _M_mask(__y) { }
>
> _Bit_reference() noexcept : _M_p(0), _M_mask(0) { }
>
> operator bool() const noexcept
> { return !!(*_M_p & _M_mask); }
>
> _Bit_reference&
> operator=(bool __x) noexcept
> {
> if (__x)
> *_M_p |= _M_mask;
> else
> *_M_p &= ~_M_mask;
> return *this;
> }
>
> _Bit_reference&
> operator=(const _Bit_reference& __x) noexcept
> { return *this = bool(__x); }
>
> bool
> operator==(const _Bit_reference& __x) const
> { return bool(*this) == bool(__x); }
>
> bool
> operator<(const _Bit_reference& __x) const
> { return !bool(*this) && bool(__x); }
>
> void
> flip() noexcept
> { *_M_p ^= _M_mask; }
> };
>
>
> inline void
> swap(_Bit_reference __x, _Bit_reference __y) noexcept
> {
> bool __tmp = __x;
> __x = __y;
> __y = __tmp;
> }
>
> inline void
> swap(_Bit_reference __x, bool& __y) noexcept
> {
> bool __tmp = __x;
> __x = __y;
> __y = __tmp;
> }
>
> inline void
> swap(bool& __x, _Bit_reference __y) noexcept
> {
> bool __tmp = __x;
> __x = __y;
> __y = __tmp;
> }
>
>
> struct _Bit_iterator_base
> : public std::iterator<std::random_access_iterator_tag, bool>
> {
> _Bit_type * _M_p;
> unsigned int _M_offset;
>
> _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
> : _M_p(__x), _M_offset(__y) { }
>
> void
> _M_bump_up()
> {
> if (_M_offset++ == int(_S_word_bit) - 1)
> {
> _M_offset = 0;
> ++_M_p;
> }
> }
>
> void
> _M_bump_down()
> {
> if (_M_offset-- == 0)
> {
> _M_offset = int(_S_word_bit) - 1;
> --_M_p;
> }
> }
>
> void
> _M_incr(ptrdiff_t __i)
> {
> difference_type __n = __i + _M_offset;
> _M_p += __n / int(_S_word_bit);
> __n = __n % int(_S_word_bit);
> if (__n < 0)
> {
> __n += int(_S_word_bit);
> --_M_p;
> }
> _M_offset = static_cast<unsigned int>(__n);
> }
>
> bool
> operator==(const _Bit_iterator_base& __i) const
> { return _M_p == __i._M_p && _M_offset == __i._M_offset; }
>
> bool
> operator<(const _Bit_iterator_base& __i) const
> {
> return _M_p < __i._M_p
> || (_M_p == __i._M_p && _M_offset < __i._M_offset);
> }
>
> bool
> operator!=(const _Bit_iterator_base& __i) const
> { return !(*this == __i); }
>
> bool
> operator>(const _Bit_iterator_base& __i) const
> { return __i < *this; }
>
> bool
> operator<=(const _Bit_iterator_base& __i) const
> { return !(__i < *this); }
>
> bool
> operator>=(const _Bit_iterator_base& __i) const
> { return !(*this < __i); }
> };
>
> inline ptrdiff_t
> operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
> {
> return (int(_S_word_bit) * (__x._M_p - __y._M_p)
> + __x._M_offset - __y._M_offset);
> }
>
> struct _Bit_iterator : public _Bit_iterator_base
> {
> typedef _Bit_reference reference;
> typedef _Bit_reference* pointer;
> typedef _Bit_iterator iterator;
>
> _Bit_iterator() : _Bit_iterator_base(0, 0) { }
>
> _Bit_iterator(_Bit_type * __x, unsigned int __y)
> : _Bit_iterator_base(__x, __y) { }
>
> reference
> operator*() const
> { return reference(_M_p, 1UL << _M_offset); }
>
> iterator&
> operator++()
> {
> _M_bump_up();
> return *this;
> }
>
> iterator
> operator++(int)
> {
> iterator __tmp = *this;
> _M_bump_up();
> return __tmp;
> }
>
> iterator&
> operator--()
> {
> _M_bump_down();
> return *this;
> }
>
> iterator
> operator--(int)
> {
> iterator __tmp = *this;
> _M_bump_down();
> return __tmp;
> }
>
> iterator&
> operator+=(difference_type __i)
> {
> _M_incr(__i);
> return *this;
> }
>
> iterator&
> operator-=(difference_type __i)
> {
> *this += -__i;
> return *this;
> }
>
> iterator
> operator+(difference_type __i) const
> {
> iterator __tmp = *this;
> return __tmp += __i;
> }
>
> iterator
> operator-(difference_type __i) const
> {
> iterator __tmp = *this;
> return __tmp -= __i;
> }
>
> reference
> operator[](difference_type __i) const
> { return *(*this + __i); }
> };
>
> inline _Bit_iterator
> operator+(ptrdiff_t __n, const _Bit_iterator& __x)
> { return __x + __n; }
>
> struct _Bit_const_iterator : public _Bit_iterator_base
> {
> typedef bool reference;
> typedef bool const_reference;
> typedef const bool* pointer;
> typedef _Bit_const_iterator const_iterator;
>
> _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
>
> _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
> : _Bit_iterator_base(__x, __y) { }
>
> _Bit_const_iterator(const _Bit_iterator& __x)
> : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
>
> const_reference
> operator*() const
> { return _Bit_reference(_M_p, 1UL << _M_offset); }
>
> const_iterator&
> operator++()
> {
> _M_bump_up();
> return *this;
> }
>
> const_iterator
> operator++(int)
> {
> const_iterator __tmp = *this;
> _M_bump_up();
> return __tmp;
> }
>
> const_iterator&
> operator--()
> {
> _M_bump_down();
> return *this;
> }
>
> const_iterator
> operator--(int)
> {
> const_iterator __tmp = *this;
> _M_bump_down();
> return __tmp;
> }
>
> const_iterator&
> operator+=(difference_type __i)
> {
> _M_incr(__i);
> return *this;
> }
>
> const_iterator&
> operator-=(difference_type __i)
> {
> *this += -__i;
> return *this;
> }
>
> const_iterator
> operator+(difference_type __i) const
> {
> const_iterator __tmp = *this;
> return __tmp += __i;
> }
>
> const_iterator
> operator-(difference_type __i) const
> {
> const_iterator __tmp = *this;
> return __tmp -= __i;
> }
>
> const_reference
> operator[](difference_type __i) const
> { return *(*this + __i); }
> };
>
> inline _Bit_const_iterator
> operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
> { return __x + __n; }
>
> inline void
> __fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x)
> {
> for (; __first != __last; ++__first)
> *__first = __x;
> }
>
> inline void
> fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
> {
> if (__first._M_p != __last._M_p)
> {
> std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0);
> __fill_bvector(__first, _Bit_iterator(__first._M_p + 1, 0), __x);
> __fill_bvector(_Bit_iterator(__last._M_p, 0), __last, __x);
> }
> else
> __fill_bvector(__first, __last, __x);
> }
>
> template<typename _Alloc>
> struct _Bvector_base
> {
> typedef typename _Alloc::template rebind<_Bit_type>::other
> _Bit_alloc_type;
>
> struct _Bvector_impl
> : public _Bit_alloc_type
> {
> _Bit_iterator _M_start;
> _Bit_iterator _M_finish;
> _Bit_type* _M_end_of_storage;
>
> _Bvector_impl()
> : _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage(0)
> { }
>
> _Bvector_impl(const _Bit_alloc_type& __a)
> : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0)
> { }
>
>
> _Bvector_impl(_Bit_alloc_type&& __a)
> : _Bit_alloc_type(std::move(__a)), _M_start(), _M_finish(),
> _M_end_of_storage(0)
> { }
>
> };
>
> public:
> typedef _Alloc allocator_type;
>
> _Bit_alloc_type&
> _M_get_Bit_allocator() noexcept
> { return *static_cast<_Bit_alloc_type*>(&this->_M_impl); }
>
> const _Bit_alloc_type&
> _M_get_Bit_allocator() const noexcept
> { return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
>
> allocator_type
> get_allocator() const noexcept
> { return allocator_type(_M_get_Bit_allocator()); }
>
> _Bvector_base()
> : _M_impl() { }
>
> _Bvector_base(const allocator_type& __a)
> : _M_impl(__a) { }
>
>
> _Bvector_base(_Bvector_base&& __x) noexcept
> : _M_impl(std::move(__x._M_get_Bit_allocator()))
> {
> this->_M_impl._M_start = __x._M_impl._M_start;
> this->_M_impl._M_finish = __x._M_impl._M_finish;
> this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
> __x._M_impl._M_start = _Bit_iterator();
> __x._M_impl._M_finish = _Bit_iterator();
> __x._M_impl._M_end_of_storage = 0;
> }
>
>
> ~_Bvector_base()
> { this->_M_deallocate(); }
>
> protected:
> _Bvector_impl _M_impl;
>
> _Bit_type*
> _M_allocate(size_t __n)
> { return _M_impl.allocate(_S_nword(__n)); }
>
> void
> _M_deallocate()
> {
> if (_M_impl._M_start._M_p)
> _M_impl.deallocate(_M_impl._M_start._M_p,
> _M_impl._M_end_of_storage - _M_impl._M_start._M_p);
> }
>
> static size_t
> _S_nword(size_t __n)
> { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
> };
>
>
>}
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 517 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
>template<typename _Alloc>
> class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
> {
> typedef _Bvector_base<_Alloc> _Base;
>
>
> template<typename> friend struct hash;
>
>
> public:
> typedef bool value_type;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Bit_reference reference;
> typedef bool const_reference;
> typedef _Bit_reference* pointer;
> typedef const bool* const_pointer;
> typedef _Bit_iterator iterator;
> typedef _Bit_const_iterator const_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef _Alloc allocator_type;
>
> allocator_type get_allocator() const
> { return _Base::get_allocator(); }
>
> protected:
> using _Base::_M_allocate;
> using _Base::_M_deallocate;
> using _Base::_S_nword;
> using _Base::_M_get_Bit_allocator;
>
> public:
> vector()
> : _Base() { }
>
> explicit
> vector(const allocator_type& __a)
> : _Base(__a) { }
>
>
> explicit
> vector(size_type __n, const allocator_type& __a = allocator_type())
> : vector(__n, false, __a)
> { }
>
> vector(size_type __n, const bool& __value,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> {
> _M_initialize(__n);
> std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage,
> __value ? ~0 : 0);
> }
># 583 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
> vector(const vector& __x)
> : _Base(__x._M_get_Bit_allocator())
> {
> _M_initialize(__x.size());
> _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
> }
>
>
> vector(vector&& __x) noexcept
> : _Base(std::move(__x)) { }
>
> vector(initializer_list<bool> __l,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> {
> _M_initialize_range(__l.begin(), __l.end(),
> random_access_iterator_tag());
> }
>
>
>
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> vector(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> { _M_initialize_dispatch(__first, __last, __false_type()); }
># 621 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
> ~vector() noexcept { }
>
> vector&
> operator=(const vector& __x)
> {
> if (&__x == this)
> return *this;
> if (__x.size() > capacity())
> {
> this->_M_deallocate();
> _M_initialize(__x.size());
> }
> this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
> begin());
> return *this;
> }
>
>
> vector&
> operator=(vector&& __x)
> {
>
>
> this->clear();
> this->swap(__x);
> return *this;
> }
>
> vector&
> operator=(initializer_list<bool> __l)
> {
> this->assign (__l.begin(), __l.end());
> return *this;
> }
>
>
>
>
>
>
> void
> assign(size_type __n, const bool& __x)
> { _M_fill_assign(__n, __x); }
>
>
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> void
> assign(_InputIterator __first, _InputIterator __last)
> { _M_assign_dispatch(__first, __last, __false_type()); }
># 682 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
> void
> assign(initializer_list<bool> __l)
> { this->assign(__l.begin(), __l.end()); }
>
>
> iterator
> begin() noexcept
> { return this->_M_impl._M_start; }
>
> const_iterator
> begin() const noexcept
> { return this->_M_impl._M_start; }
>
> iterator
> end() noexcept
> { return this->_M_impl._M_finish; }
>
> const_iterator
> end() const noexcept
> { return this->_M_impl._M_finish; }
>
> reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(end()); }
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
> reverse_iterator
> rend() noexcept
> { return reverse_iterator(begin()); }
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
> const_iterator
> cbegin() const noexcept
> { return this->_M_impl._M_start; }
>
> const_iterator
> cend() const noexcept
> { return this->_M_impl._M_finish; }
>
> const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
> const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
> size_type
> size() const noexcept
> { return size_type(end() - begin()); }
>
> size_type
> max_size() const noexcept
> {
> const size_type __isize =
> __gnu_cxx::__numeric_traits<difference_type>::__max
> - int(_S_word_bit) + 1;
> const size_type __asize = _M_get_Bit_allocator().max_size();
> return (__asize <= __isize / int(_S_word_bit)
> ? __asize * int(_S_word_bit) : __isize);
> }
>
> size_type
> capacity() const noexcept
> { return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
> - begin()); }
>
> bool
> empty() const noexcept
> { return begin() == end(); }
>
> reference
> operator[](size_type __n)
> {
> return *iterator(this->_M_impl._M_start._M_p
> + __n / int(_S_word_bit), __n % int(_S_word_bit));
> }
>
> const_reference
> operator[](size_type __n) const
> {
> return *const_iterator(this->_M_impl._M_start._M_p
> + __n / int(_S_word_bit), __n % int(_S_word_bit));
> }
>
> protected:
> void
> _M_range_check(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range(("vector<bool>::_M_range_check"));
> }
>
> public:
> reference
> at(size_type __n)
> { _M_range_check(__n); return (*this)[__n]; }
>
> const_reference
> at(size_type __n) const
> { _M_range_check(__n); return (*this)[__n]; }
>
> void
> reserve(size_type __n)
> {
> if (__n > max_size())
> __throw_length_error(("vector::reserve"));
> if (capacity() < __n)
> _M_reallocate(__n);
> }
>
> reference
> front()
> { return *begin(); }
>
> const_reference
> front() const
> { return *begin(); }
>
> reference
> back()
> { return *(end() - 1); }
>
> const_reference
> back() const
> { return *(end() - 1); }
>
>
>
>
>
>
> void
> data() noexcept { }
>
> void
> push_back(bool __x)
> {
> if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
> *this->_M_impl._M_finish++ = __x;
> else
> _M_insert_aux(end(), __x);
> }
>
> void
> swap(vector& __x)
> {
> std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
> std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
> std::swap(this->_M_impl._M_end_of_storage,
> __x._M_impl._M_end_of_storage);
>
>
>
> std::__alloc_swap<typename _Base::_Bit_alloc_type>::
> _S_do_it(_M_get_Bit_allocator(), __x._M_get_Bit_allocator());
> }
>
>
> static void
> swap(reference __x, reference __y) noexcept
> {
> bool __tmp = __x;
> __x = __y;
> __y = __tmp;
> }
>
> iterator
> insert(iterator __position, const bool& __x = bool())
> {
> const difference_type __n = __position - begin();
> if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
> && __position == end())
> *this->_M_impl._M_finish++ = __x;
> else
> _M_insert_aux(__position, __x);
> return begin() + __n;
> }
>
>
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> void
> insert(iterator __position,
> _InputIterator __first, _InputIterator __last)
> { _M_insert_dispatch(__position, __first, __last, __false_type()); }
># 887 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
> void
> insert(iterator __position, size_type __n, const bool& __x)
> { _M_fill_insert(__position, __n, __x); }
>
>
> void insert(iterator __p, initializer_list<bool> __l)
> { this->insert(__p, __l.begin(), __l.end()); }
>
>
> void
> pop_back()
> { --this->_M_impl._M_finish; }
>
> iterator
> erase(iterator __position)
> {
> if (__position + 1 != end())
> std::copy(__position + 1, end(), __position);
> --this->_M_impl._M_finish;
> return __position;
> }
>
> iterator
> erase(iterator __first, iterator __last)
> {
> if (__first != __last)
> _M_erase_at_end(std::copy(__last, end(), __first));
> return __first;
> }
>
> void
> resize(size_type __new_size, bool __x = bool())
> {
> if (__new_size < size())
> _M_erase_at_end(begin() + difference_type(__new_size));
> else
> insert(end(), __new_size - size(), __x);
> }
>
>
> void
> shrink_to_fit()
> { _M_shrink_to_fit(); }
>
>
> void
> flip() noexcept
> {
> for (_Bit_type * __p = this->_M_impl._M_start._M_p;
> __p != this->_M_impl._M_end_of_storage; ++__p)
> *__p = ~*__p;
> }
>
> void
> clear() noexcept
> { _M_erase_at_end(begin()); }
>
>
> protected:
>
> iterator
> _M_copy_aligned(const_iterator __first, const_iterator __last,
> iterator __result)
> {
> _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
> return std::copy(const_iterator(__last._M_p, 0), __last,
> iterator(__q, 0));
> }
>
> void
> _M_initialize(size_type __n)
> {
> _Bit_type* __q = this->_M_allocate(__n);
> this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
> this->_M_impl._M_start = iterator(__q, 0);
> this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
> }
>
> void
> _M_reallocate(size_type __n);
>
>
> bool
> _M_shrink_to_fit();
>
>
>
>
>
>
> template<typename _Integer>
> void
> _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
> {
> _M_initialize(static_cast<size_type>(__n));
> std::fill(this->_M_impl._M_start._M_p,
> this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
> }
>
> template<typename _InputIterator>
> void
> _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> { _M_initialize_range(__first, __last,
> std::__iterator_category(__first)); }
>
> template<typename _InputIterator>
> void
> _M_initialize_range(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> for (; __first != __last; ++__first)
> push_back(*__first);
> }
>
> template<typename _ForwardIterator>
> void
> _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __n = std::distance(__first, __last);
> _M_initialize(__n);
> std::copy(__first, __last, this->_M_impl._M_start);
> }
>
>
>
> template<typename _Integer>
> void
> _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> { _M_fill_assign(__n, __val); }
>
> template<class _InputIterator>
> void
> _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
>
> void
> _M_fill_assign(size_t __n, bool __x)
> {
> if (__n > size())
> {
> std::fill(this->_M_impl._M_start._M_p,
> this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
> insert(end(), __n - size(), __x);
> }
> else
> {
> _M_erase_at_end(begin() + __n);
> std::fill(this->_M_impl._M_start._M_p,
> this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
> }
> }
>
> template<typename _InputIterator>
> void
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> iterator __cur = begin();
> for (; __first != __last && __cur != end(); ++__cur, ++__first)
> *__cur = *__first;
> if (__first == __last)
> _M_erase_at_end(__cur);
> else
> insert(end(), __first, __last);
> }
>
> template<typename _ForwardIterator>
> void
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __len = std::distance(__first, __last);
> if (__len < size())
> _M_erase_at_end(std::copy(__first, __last, begin()));
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, size());
> std::copy(__first, __mid, begin());
> insert(end(), __mid, __last);
> }
> }
>
>
>
>
>
> template<typename _Integer>
> void
> _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
> __true_type)
> { _M_fill_insert(__pos, __n, __x); }
>
> template<typename _InputIterator>
> void
> _M_insert_dispatch(iterator __pos,
> _InputIterator __first, _InputIterator __last,
> __false_type)
> { _M_insert_range(__pos, __first, __last,
> std::__iterator_category(__first)); }
>
> void
> _M_fill_insert(iterator __position, size_type __n, bool __x);
>
> template<typename _InputIterator>
> void
> _M_insert_range(iterator __pos, _InputIterator __first,
> _InputIterator __last, std::input_iterator_tag)
> {
> for (; __first != __last; ++__first)
> {
> __pos = insert(__pos, *__first);
> ++__pos;
> }
> }
>
> template<typename _ForwardIterator>
> void
> _M_insert_range(iterator __position, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag);
>
> void
> _M_insert_aux(iterator __position, bool __x);
>
> size_type
> _M_check_len(size_type __n, const char* __s) const
> {
> if (max_size() - size() < __n)
> __throw_length_error((__s));
>
> const size_type __len = size() + std::max(size(), __n);
> return (__len < size() || __len > max_size()) ? max_size() : __len;
> }
>
> void
> _M_erase_at_end(iterator __pos)
> { this->_M_impl._M_finish = __pos; }
> };
>
>
>}
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
> template<typename _Alloc>
> struct hash<std::vector<bool, _Alloc>>
> : public __hash_base<size_t, std::vector<bool, _Alloc>>
> {
> size_t
> operator()(const std::vector<bool, _Alloc>&) const noexcept;
> };
>
>
>}
># 66 "/usr/include/c++/4.8.2/vector" 2 3
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/vector.tcc" 1 3
># 59 "/usr/include/c++/4.8.2/bits/vector.tcc" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> reserve(size_type __n)
> {
> if (__n > this->max_size())
> __throw_length_error(("vector::reserve"));
> if (this->capacity() < __n)
> {
> const size_type __old_size = size();
> pointer __tmp = _M_allocate_and_copy(__n,
> std::__make_move_if_noexcept_iterator(this->_M_impl._M_start),
> std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish));
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __tmp;
> this->_M_impl._M_finish = __tmp + __old_size;
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
> }
> }
>
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
> void
> vector<_Tp, _Alloc>::
> emplace_back(_Args&&... __args)
> {
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
> {
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
> std::forward<_Args>(__args)...);
> ++this->_M_impl._M_finish;
> }
> else
> _M_emplace_back_aux(std::forward<_Args>(__args)...);
> }
>
>
> template<typename _Tp, typename _Alloc>
> typename vector<_Tp, _Alloc>::iterator
> vector<_Tp, _Alloc>::
> insert(iterator __position, const value_type& __x)
> {
> const size_type __n = __position - begin();
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
> && __position == end())
> {
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, __x);
> ++this->_M_impl._M_finish;
> }
> else
> {
>
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
> {
> _Tp __x_copy = __x;
> _M_insert_aux(__position, std::move(__x_copy));
> }
> else
>
> _M_insert_aux(__position, __x);
> }
> return iterator(this->_M_impl._M_start + __n);
> }
>
> template<typename _Tp, typename _Alloc>
> typename vector<_Tp, _Alloc>::iterator
> vector<_Tp, _Alloc>::
> erase(iterator __position)
> {
> if (__position + 1 != end())
> std::move(__position + 1, end(), __position);
> --this->_M_impl._M_finish;
> _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
> return __position;
> }
>
> template<typename _Tp, typename _Alloc>
> typename vector<_Tp, _Alloc>::iterator
> vector<_Tp, _Alloc>::
> erase(iterator __first, iterator __last)
> {
> if (__first != __last)
> {
> if (__last != end())
> std::move(__last, end(), __first);
> _M_erase_at_end(__first.base() + (end() - __last));
> }
> return __first;
> }
>
> template<typename _Tp, typename _Alloc>
> vector<_Tp, _Alloc>&
> vector<_Tp, _Alloc>::
> operator=(const vector<_Tp, _Alloc>& __x)
> {
> if (&__x != this)
> {
>
> if (_Alloc_traits::_S_propagate_on_copy_assign())
> {
> if (!_Alloc_traits::_S_always_equal()
> && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
> {
>
> this->clear();
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = nullptr;
> this->_M_impl._M_finish = nullptr;
> this->_M_impl._M_end_of_storage = nullptr;
> }
> std::__alloc_on_copy(_M_get_Tp_allocator(),
> __x._M_get_Tp_allocator());
> }
>
> const size_type __xlen = __x.size();
> if (__xlen > capacity())
> {
> pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
> __x.end());
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __tmp;
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
> }
> else if (size() >= __xlen)
> {
> std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
> end(), _M_get_Tp_allocator());
> }
> else
> {
> std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
> this->_M_impl._M_start);
> std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
> __x._M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> }
> this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
> }
> return *this;
> }
>
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> _M_fill_assign(size_t __n, const value_type& __val)
> {
> if (__n > capacity())
> {
> vector __tmp(__n, __val, _M_get_Tp_allocator());
> __tmp.swap(*this);
> }
> else if (__n > size())
> {
> std::fill(begin(), end(), __val);
> std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
> __n - size(), __val,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n - size();
> }
> else
> _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename _InputIterator>
> void
> vector<_Tp, _Alloc>::
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> pointer __cur(this->_M_impl._M_start);
> for (; __first != __last && __cur != this->_M_impl._M_finish;
> ++__cur, ++__first)
> *__cur = *__first;
> if (__first == __last)
> _M_erase_at_end(__cur);
> else
> insert(end(), __first, __last);
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename _ForwardIterator>
> void
> vector<_Tp, _Alloc>::
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __len = std::distance(__first, __last);
>
> if (__len > capacity())
> {
> pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __tmp;
> this->_M_impl._M_finish = this->_M_impl._M_start + __len;
> this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
> }
> else if (size() >= __len)
> _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, size());
> std::copy(__first, __mid, this->_M_impl._M_start);
> this->_M_impl._M_finish =
> std::__uninitialized_copy_a(__mid, __last,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> }
> }
>
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
> typename vector<_Tp, _Alloc>::iterator
> vector<_Tp, _Alloc>::
> emplace(iterator __position, _Args&&... __args)
> {
> const size_type __n = __position - begin();
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
> && __position == end())
> {
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
> std::forward<_Args>(__args)...);
> ++this->_M_impl._M_finish;
> }
> else
> _M_insert_aux(__position, std::forward<_Args>(__args)...);
> return iterator(this->_M_impl._M_start + __n);
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
> void
> vector<_Tp, _Alloc>::
> _M_insert_aux(iterator __position, _Args&&... __args)
>
>
>
>
>
>
> {
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
> {
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
> std::move(*(this->_M_impl._M_finish - 1))
> );
> ++this->_M_impl._M_finish;
>
>
>
> std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1)
>
> ;
>
>
>
> *__position = _Tp(std::forward<_Args>(__args)...);
>
> }
> else
> {
> const size_type __len =
> _M_check_len(size_type(1), "vector::_M_insert_aux");
> const size_type __elems_before = __position - begin();
> pointer __new_start(this->_M_allocate(__len));
> pointer __new_finish(__new_start);
> try
> {
>
>
>
>
> _Alloc_traits::construct(this->_M_impl,
> __new_start + __elems_before,
>
> std::forward<_Args>(__args)...);
>
>
>
> __new_finish = 0;
>
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (this->_M_impl._M_start, __position.base(),
> __new_start, _M_get_Tp_allocator());
>
> ++__new_finish;
>
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (__position.base(), this->_M_impl._M_finish,
> __new_finish, _M_get_Tp_allocator());
> }
> catch(...)
> {
> if (!__new_finish)
> _Alloc_traits::destroy(this->_M_impl,
> __new_start + __elems_before);
> else
> std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
> _M_deallocate(__new_start, __len);
> throw;
> }
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start;
> this->_M_impl._M_finish = __new_finish;
> this->_M_impl._M_end_of_storage = __new_start + __len;
> }
> }
>
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
> void
> vector<_Tp, _Alloc>::
> _M_emplace_back_aux(_Args&&... __args)
> {
> const size_type __len =
> _M_check_len(size_type(1), "vector::_M_emplace_back_aux");
> pointer __new_start(this->_M_allocate(__len));
> pointer __new_finish(__new_start);
> try
> {
> _Alloc_traits::construct(this->_M_impl, __new_start + size(),
> std::forward<_Args>(__args)...);
> __new_finish = 0;
>
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (this->_M_impl._M_start, this->_M_impl._M_finish,
> __new_start, _M_get_Tp_allocator());
>
> ++__new_finish;
> }
> catch(...)
> {
> if (!__new_finish)
> _Alloc_traits::destroy(this->_M_impl, __new_start + size());
> else
> std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
> _M_deallocate(__new_start, __len);
> throw;
> }
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start;
> this->_M_impl._M_finish = __new_finish;
> this->_M_impl._M_end_of_storage = __new_start + __len;
> }
>
>
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
> {
> if (__n != 0)
> {
> if (size_type(this->_M_impl._M_end_of_storage
> - this->_M_impl._M_finish) >= __n)
> {
> value_type __x_copy = __x;
> const size_type __elems_after = end() - __position;
> pointer __old_finish(this->_M_impl._M_finish);
> if (__elems_after > __n)
> {
> std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n;
> std::move_backward(__position.base(), __old_finish - __n, __old_finish)
> ;
> std::fill(__position.base(), __position.base() + __n,
> __x_copy);
> }
> else
> {
> std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
> __n - __elems_after,
> __x_copy,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n - __elems_after;
> std::__uninitialized_move_a(__position.base(), __old_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __elems_after;
> std::fill(__position.base(), __old_finish, __x_copy);
> }
> }
> else
> {
> const size_type __len =
> _M_check_len(__n, "vector::_M_fill_insert");
> const size_type __elems_before = __position - begin();
> pointer __new_start(this->_M_allocate(__len));
> pointer __new_finish(__new_start);
> try
> {
>
> std::__uninitialized_fill_n_a(__new_start + __elems_before,
> __n, __x,
> _M_get_Tp_allocator());
> __new_finish = 0;
>
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (this->_M_impl._M_start, __position.base(),
> __new_start, _M_get_Tp_allocator());
>
> __new_finish += __n;
>
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (__position.base(), this->_M_impl._M_finish,
> __new_finish, _M_get_Tp_allocator());
> }
> catch(...)
> {
> if (!__new_finish)
> std::_Destroy(__new_start + __elems_before,
> __new_start + __elems_before + __n,
> _M_get_Tp_allocator());
> else
> std::_Destroy(__new_start, __new_finish,
> _M_get_Tp_allocator());
> _M_deallocate(__new_start, __len);
> throw;
> }
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start;
> this->_M_impl._M_finish = __new_finish;
> this->_M_impl._M_end_of_storage = __new_start + __len;
> }
> }
> }
>
>
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> _M_default_append(size_type __n)
> {
> if (__n != 0)
> {
> if (size_type(this->_M_impl._M_end_of_storage
> - this->_M_impl._M_finish) >= __n)
> {
> std::__uninitialized_default_n_a(this->_M_impl._M_finish,
> __n, _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n;
> }
> else
> {
> const size_type __len =
> _M_check_len(__n, "vector::_M_default_append");
> const size_type __old_size = this->size();
> pointer __new_start(this->_M_allocate(__len));
> pointer __new_finish(__new_start);
> try
> {
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (this->_M_impl._M_start, this->_M_impl._M_finish,
> __new_start, _M_get_Tp_allocator());
> std::__uninitialized_default_n_a(__new_finish, __n,
> _M_get_Tp_allocator());
> __new_finish += __n;
> }
> catch(...)
> {
> std::_Destroy(__new_start, __new_finish,
> _M_get_Tp_allocator());
> _M_deallocate(__new_start, __len);
> throw;
> }
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start;
> this->_M_impl._M_finish = __new_finish;
> this->_M_impl._M_end_of_storage = __new_start + __len;
> }
> }
> }
>
> template<typename _Tp, typename _Alloc>
> bool
> vector<_Tp, _Alloc>::
> _M_shrink_to_fit()
> {
> if (capacity() == size())
> return false;
> return std::__shrink_to_fit_aux<vector>::_S_do_it(*this);
> }
>
>
> template<typename _Tp, typename _Alloc>
> template<typename _InputIterator>
> void
> vector<_Tp, _Alloc>::
> _M_range_insert(iterator __pos, _InputIterator __first,
> _InputIterator __last, std::input_iterator_tag)
> {
> for (; __first != __last; ++__first)
> {
> __pos = insert(__pos, *__first);
> ++__pos;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename _ForwardIterator>
> void
> vector<_Tp, _Alloc>::
> _M_range_insert(iterator __position, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag)
> {
> if (__first != __last)
> {
> const size_type __n = std::distance(__first, __last);
> if (size_type(this->_M_impl._M_end_of_storage
> - this->_M_impl._M_finish) >= __n)
> {
> const size_type __elems_after = end() - __position;
> pointer __old_finish(this->_M_impl._M_finish);
> if (__elems_after > __n)
> {
> std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n;
> std::move_backward(__position.base(), __old_finish - __n, __old_finish)
> ;
> std::copy(__first, __last, __position);
> }
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, __elems_after);
> std::__uninitialized_copy_a(__mid, __last,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n - __elems_after;
> std::__uninitialized_move_a(__position.base(),
> __old_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __elems_after;
> std::copy(__first, __mid, __position);
> }
> }
> else
> {
> const size_type __len =
> _M_check_len(__n, "vector::_M_range_insert");
> pointer __new_start(this->_M_allocate(__len));
> pointer __new_finish(__new_start);
> try
> {
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (this->_M_impl._M_start, __position.base(),
> __new_start, _M_get_Tp_allocator());
> __new_finish
> = std::__uninitialized_copy_a(__first, __last,
> __new_finish,
> _M_get_Tp_allocator());
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (__position.base(), this->_M_impl._M_finish,
> __new_finish, _M_get_Tp_allocator());
> }
> catch(...)
> {
> std::_Destroy(__new_start, __new_finish,
> _M_get_Tp_allocator());
> _M_deallocate(__new_start, __len);
> throw;
> }
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start;
> this->_M_impl._M_finish = __new_finish;
> this->_M_impl._M_end_of_storage = __new_start + __len;
> }
> }
> }
>
>
>
> template<typename _Alloc>
> void
> vector<bool, _Alloc>::
> _M_reallocate(size_type __n)
> {
> _Bit_type* __q = this->_M_allocate(__n);
> this->_M_impl._M_finish = _M_copy_aligned(begin(), end(),
> iterator(__q, 0));
> this->_M_deallocate();
> this->_M_impl._M_start = iterator(__q, 0);
> this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
> }
>
> template<typename _Alloc>
> void
> vector<bool, _Alloc>::
> _M_fill_insert(iterator __position, size_type __n, bool __x)
> {
> if (__n == 0)
> return;
> if (capacity() - size() >= __n)
> {
> std::copy_backward(__position, end(),
> this->_M_impl._M_finish + difference_type(__n));
> std::fill(__position, __position + difference_type(__n), __x);
> this->_M_impl._M_finish += difference_type(__n);
> }
> else
> {
> const size_type __len =
> _M_check_len(__n, "vector<bool>::_M_fill_insert");
> _Bit_type * __q = this->_M_allocate(__len);
> iterator __i = _M_copy_aligned(begin(), __position,
> iterator(__q, 0));
> std::fill(__i, __i + difference_type(__n), __x);
> this->_M_impl._M_finish = std::copy(__position, end(),
> __i + difference_type(__n));
> this->_M_deallocate();
> this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
> this->_M_impl._M_start = iterator(__q, 0);
> }
> }
>
> template<typename _Alloc>
> template<typename _ForwardIterator>
> void
> vector<bool, _Alloc>::
> _M_insert_range(iterator __position, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag)
> {
> if (__first != __last)
> {
> size_type __n = std::distance(__first, __last);
> if (capacity() - size() >= __n)
> {
> std::copy_backward(__position, end(),
> this->_M_impl._M_finish
> + difference_type(__n));
> std::copy(__first, __last, __position);
> this->_M_impl._M_finish += difference_type(__n);
> }
> else
> {
> const size_type __len =
> _M_check_len(__n, "vector<bool>::_M_insert_range");
> _Bit_type * __q = this->_M_allocate(__len);
> iterator __i = _M_copy_aligned(begin(), __position,
> iterator(__q, 0));
> __i = std::copy(__first, __last, __i);
> this->_M_impl._M_finish = std::copy(__position, end(), __i);
> this->_M_deallocate();
> this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
> this->_M_impl._M_start = iterator(__q, 0);
> }
> }
> }
>
> template<typename _Alloc>
> void
> vector<bool, _Alloc>::
> _M_insert_aux(iterator __position, bool __x)
> {
> if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
> {
> std::copy_backward(__position, this->_M_impl._M_finish,
> this->_M_impl._M_finish + 1);
> *__position = __x;
> ++this->_M_impl._M_finish;
> }
> else
> {
> const size_type __len =
> _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
> _Bit_type * __q = this->_M_allocate(__len);
> iterator __i = _M_copy_aligned(begin(), __position,
> iterator(__q, 0));
> *__i++ = __x;
> this->_M_impl._M_finish = std::copy(__position, end(), __i);
> this->_M_deallocate();
> this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
> this->_M_impl._M_start = iterator(__q, 0);
> }
> }
>
>
> template<typename _Alloc>
> bool
> vector<bool, _Alloc>::
> _M_shrink_to_fit()
> {
> if (capacity() - size() < int(_S_word_bit))
> return false;
> try
> {
> _M_reallocate(size());
> return true;
> }
> catch(...)
> { return false; }
> }
>
>
>
>}
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Alloc>
> size_t
> hash<std::vector<bool, _Alloc>>::
> operator()(const std::vector<bool, _Alloc>& __b) const noexcept
> {
> size_t __hash = 0;
> using std::_S_word_bit;
> using std::_Bit_type;
>
> const size_t __words = __b.size() / _S_word_bit;
> if (__words)
> {
> const size_t __clength = __words * sizeof(_Bit_type);
> __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength);
> }
>
> const size_t __extrabits = __b.size() % _S_word_bit;
> if (__extrabits)
> {
> _Bit_type __hiword = *__b._M_impl._M_finish._M_p;
> __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits);
>
> const size_t __clength
> = (__extrabits + 8 - 1) / 8;
> if (__words)
> __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash);
> else
> __hash = std::_Hash_impl::hash(&__hiword, __clength);
> }
>
> return __hash;
> }
>
>
>}
># 70 "/usr/include/c++/4.8.2/vector" 2 3
># 19 "../src/wildfire.h" 2
>
># 1 "/usr/include/c++/4.8.2/cstdlib" 1 3
># 39 "/usr/include/c++/4.8.2/cstdlib" 3
> 
># 40 "/usr/include/c++/4.8.2/cstdlib" 3
># 21 "../src/wildfire.h" 2
>
>
># 1 "/usr/include/boost/circular_buffer.hpp" 1 3 4
># 18 "/usr/include/boost/circular_buffer.hpp" 3 4
># 1 "/usr/include/boost/circular_buffer_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/circular_buffer_fwd.hpp" 3 4
># 1 "/usr/include/boost/config.hpp" 1 3 4
># 26 "/usr/include/boost/config.hpp" 3 4
># 1 "/usr/include/boost/config/user.hpp" 1 3 4
># 27 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/config/select_compiler_config.hpp" 1 3 4
># 32 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/config/compiler/gcc.hpp" 1 3 4
># 36 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/config/select_stdlib_config.hpp" 1 3 4
># 18 "/usr/include/boost/config/select_stdlib_config.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 147 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 3 4
>typedef long int ptrdiff_t;
># 422 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 3 4
>typedef struct {
> long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
> long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
>} max_align_t;
>
>
>
>
>
>
> typedef decltype(nullptr) nullptr_t;
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 19 "/usr/include/boost/config/select_stdlib_config.hpp" 2 3 4
># 37 "/usr/include/boost/config/select_stdlib_config.hpp" 3 4
># 1 "/usr/include/boost/config/no_tr1/utility.hpp" 1 3 4
># 21 "/usr/include/boost/config/no_tr1/utility.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/utility" 1 3 4
># 58 "/usr/include/c++/4.8.2/utility" 3 4
> 
># 59 "/usr/include/c++/4.8.2/utility" 3
># 69 "/usr/include/c++/4.8.2/utility" 3
># 1 "/usr/include/c++/4.8.2/bits/stl_relops.h" 1 3
># 67 "/usr/include/c++/4.8.2/bits/stl_relops.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
> namespace rel_ops
> {
> 
># 85 "/usr/include/c++/4.8.2/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator!=(const _Tp& __x, const _Tp& __y)
> { return !(__x == __y); }
># 98 "/usr/include/c++/4.8.2/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator>(const _Tp& __x, const _Tp& __y)
> { return __y < __x; }
># 111 "/usr/include/c++/4.8.2/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator<=(const _Tp& __x, const _Tp& __y)
> { return !(__y < __x); }
># 124 "/usr/include/c++/4.8.2/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator>=(const _Tp& __x, const _Tp& __y)
> { return !(__x < __y); }
>
> 
> }
>
>}
># 70 "/usr/include/c++/4.8.2/utility" 2 3
>
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<class _Tp>
> class tuple_size;
>
> template<std::size_t _Int, class _Tp>
> class tuple_element;
>
>
> template<class _Tp1, class _Tp2>
> struct tuple_size<std::pair<_Tp1, _Tp2>>
> : public integral_constant<std::size_t, 2> { };
>
> 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<std::size_t _Int>
> struct __pair_get;
>
> template<>
> struct __pair_get<0>
> {
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp1&
> __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.first; }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp1&&
> __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
> { return std::forward<_Tp1>(__pair.first); }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr const _Tp1&
> __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.first; }
> };
>
> template<>
> struct __pair_get<1>
> {
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp2&
> __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.second; }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp2&&
> __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
> { return std::forward<_Tp2>(__pair.second); }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr const _Tp2&
> __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.second; }
> };
>
> template<std::size_t _Int, class _Tp1, class _Tp2>
> constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
> get(std::pair<_Tp1, _Tp2>& __in) noexcept
> { return __pair_get<_Int>::__get(__in); }
>
> template<std::size_t _Int, class _Tp1, class _Tp2>
> constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
> get(std::pair<_Tp1, _Tp2>&& __in) noexcept
> { return __pair_get<_Int>::__move_get(std::move(__in)); }
>
> template<std::size_t _Int, class _Tp1, class _Tp2>
> constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
> get(const std::pair<_Tp1, _Tp2>& __in) noexcept
> { return __pair_get<_Int>::__const_get(__in); }
>
>
>}
># 22 "/usr/include/boost/config/no_tr1/utility.hpp" 2 3 4
># 38 "/usr/include/boost/config/select_stdlib_config.hpp" 2 3 4
># 41 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 1 3 4
># 77 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 3 4
># 1 "/usr/include/unistd.h" 1 3 4
># 27 "/usr/include/unistd.h" 3 4
>extern "C" {
># 202 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/bits/posix_opt.h" 1 3 4
># 203 "/usr/include/unistd.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/environments.h" 1 3 4
># 22 "/usr/include/bits/environments.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 23 "/usr/include/bits/environments.h" 2 3 4
># 207 "/usr/include/unistd.h" 2 3 4
># 226 "/usr/include/unistd.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 227 "/usr/include/unistd.h" 2 3 4
># 274 "/usr/include/unistd.h" 3 4
>typedef __socklen_t socklen_t;
># 287 "/usr/include/unistd.h" 3 4
>extern int access (const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int euidaccess (const char *__name, int __type)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int eaccess (const char *__name, int __type)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int faccessat (int __fd, const char *__file, int __type, int __flag)
> throw () __attribute__ ((__nonnull__ (2))) ;
># 334 "/usr/include/unistd.h" 3 4
>extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
># 345 "/usr/include/unistd.h" 3 4
>extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
> throw ();
>
>
>
>
>
>
>extern int close (int __fd);
>
>
>
>
>
>
>extern ssize_t read (int __fd, void *__buf, size_t __nbytes) ;
>
>
>
>
>
>extern ssize_t write (int __fd, const void *__buf, size_t __n) ;
># 376 "/usr/include/unistd.h" 3 4
>extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
> __off_t __offset) ;
>
>
>
>
>
>
>extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
> __off_t __offset) ;
># 404 "/usr/include/unistd.h" 3 4
>extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
> __off64_t __offset) ;
>
>
>extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
> __off64_t __offset) ;
>
>
>
>
>
>
>
>extern int pipe (int __pipedes[2]) throw () ;
>
>
>
>
>extern int pipe2 (int __pipedes[2], int __flags) throw () ;
># 432 "/usr/include/unistd.h" 3 4
>extern unsigned int alarm (unsigned int __seconds) throw ();
># 444 "/usr/include/unistd.h" 3 4
>extern unsigned int sleep (unsigned int __seconds);
>
>
>
>
>
>
>
>extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
> throw ();
>
>
>
>
>
>
>extern int usleep (__useconds_t __useconds);
># 469 "/usr/include/unistd.h" 3 4
>extern int pause (void);
>
>
>
>extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () ;
>
>
>
>
>extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>extern int fchownat (int __fd, const char *__file, __uid_t __owner,
> __gid_t __group, int __flag)
> throw () __attribute__ ((__nonnull__ (2))) ;
>
>
>
>extern int chdir (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern int fchdir (int __fd) throw () ;
># 511 "/usr/include/unistd.h" 3 4
>extern char *getcwd (char *__buf, size_t __size) throw () ;
>
>
>
>
>
>extern char *get_current_dir_name (void) throw ();
>
>
>
>
>
>
>
>extern char *getwd (char *__buf)
> throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) ;
>
>
>
>
>extern int dup (int __fd) throw () ;
>
>
>extern int dup2 (int __fd, int __fd2) throw ();
>
>
>
>
>extern int dup3 (int __fd, int __fd2, int __flags) throw ();
>
>
>
>extern char **__environ;
>
>extern char **environ;
>
>
>
>
>
>extern int execve (const char *__path, char *const __argv[],
> char *const __envp[]) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern int execv (const char *__path, char *const __argv[])
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int execle (const char *__path, const char *__arg, ...)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int execl (const char *__path, const char *__arg, ...)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int execvp (const char *__file, char *const __argv[])
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int execlp (const char *__file, const char *__arg, ...)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int execvpe (const char *__file, char *const __argv[],
> char *const __envp[])
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int nice (int __inc) throw () ;
>
>
>
>
>extern void _exit (int __status) __attribute__ ((__noreturn__));
>
>
>
>
>
># 1 "/usr/include/bits/confname.h" 1 3 4
># 24 "/usr/include/bits/confname.h" 3 4
>enum
> {
> _PC_LINK_MAX,
>
> _PC_MAX_CANON,
>
> _PC_MAX_INPUT,
>
> _PC_NAME_MAX,
>
> _PC_PATH_MAX,
>
> _PC_PIPE_BUF,
>
> _PC_CHOWN_RESTRICTED,
>
> _PC_NO_TRUNC,
>
> _PC_VDISABLE,
>
> _PC_SYNC_IO,
>
> _PC_ASYNC_IO,
>
> _PC_PRIO_IO,
>
> _PC_SOCK_MAXBUF,
>
> _PC_FILESIZEBITS,
>
> _PC_REC_INCR_XFER_SIZE,
>
> _PC_REC_MAX_XFER_SIZE,
>
> _PC_REC_MIN_XFER_SIZE,
>
> _PC_REC_XFER_ALIGN,
>
> _PC_ALLOC_SIZE_MIN,
>
> _PC_SYMLINK_MAX,
>
> _PC_2_SYMLINKS
>
> };
>
>
>enum
> {
> _SC_ARG_MAX,
>
> _SC_CHILD_MAX,
>
> _SC_CLK_TCK,
>
> _SC_NGROUPS_MAX,
>
> _SC_OPEN_MAX,
>
> _SC_STREAM_MAX,
>
> _SC_TZNAME_MAX,
>
> _SC_JOB_CONTROL,
>
> _SC_SAVED_IDS,
>
> _SC_REALTIME_SIGNALS,
>
> _SC_PRIORITY_SCHEDULING,
>
> _SC_TIMERS,
>
> _SC_ASYNCHRONOUS_IO,
>
> _SC_PRIORITIZED_IO,
>
> _SC_SYNCHRONIZED_IO,
>
> _SC_FSYNC,
>
> _SC_MAPPED_FILES,
>
> _SC_MEMLOCK,
>
> _SC_MEMLOCK_RANGE,
>
> _SC_MEMORY_PROTECTION,
>
> _SC_MESSAGE_PASSING,
>
> _SC_SEMAPHORES,
>
> _SC_SHARED_MEMORY_OBJECTS,
>
> _SC_AIO_LISTIO_MAX,
>
> _SC_AIO_MAX,
>
> _SC_AIO_PRIO_DELTA_MAX,
>
> _SC_DELAYTIMER_MAX,
>
> _SC_MQ_OPEN_MAX,
>
> _SC_MQ_PRIO_MAX,
>
> _SC_VERSION,
>
> _SC_PAGESIZE,
>
>
> _SC_RTSIG_MAX,
>
> _SC_SEM_NSEMS_MAX,
>
> _SC_SEM_VALUE_MAX,
>
> _SC_SIGQUEUE_MAX,
>
> _SC_TIMER_MAX,
>
>
>
>
> _SC_BC_BASE_MAX,
>
> _SC_BC_DIM_MAX,
>
> _SC_BC_SCALE_MAX,
>
> _SC_BC_STRING_MAX,
>
> _SC_COLL_WEIGHTS_MAX,
>
> _SC_EQUIV_CLASS_MAX,
>
> _SC_EXPR_NEST_MAX,
>
> _SC_LINE_MAX,
>
> _SC_RE_DUP_MAX,
>
> _SC_CHARCLASS_NAME_MAX,
>
>
> _SC_2_VERSION,
>
> _SC_2_C_BIND,
>
> _SC_2_C_DEV,
>
> _SC_2_FORT_DEV,
>
> _SC_2_FORT_RUN,
>
> _SC_2_SW_DEV,
>
> _SC_2_LOCALEDEF,
>
>
> _SC_PII,
>
> _SC_PII_XTI,
>
> _SC_PII_SOCKET,
>
> _SC_PII_INTERNET,
>
> _SC_PII_OSI,
>
> _SC_POLL,
>
> _SC_SELECT,
>
> _SC_UIO_MAXIOV,
>
> _SC_IOV_MAX = _SC_UIO_MAXIOV,
>
> _SC_PII_INTERNET_STREAM,
>
> _SC_PII_INTERNET_DGRAM,
>
> _SC_PII_OSI_COTS,
>
> _SC_PII_OSI_CLTS,
>
> _SC_PII_OSI_M,
>
> _SC_T_IOV_MAX,
>
>
>
> _SC_THREADS,
>
> _SC_THREAD_SAFE_FUNCTIONS,
>
> _SC_GETGR_R_SIZE_MAX,
>
> _SC_GETPW_R_SIZE_MAX,
>
> _SC_LOGIN_NAME_MAX,
>
> _SC_TTY_NAME_MAX,
>
> _SC_THREAD_DESTRUCTOR_ITERATIONS,
>
> _SC_THREAD_KEYS_MAX,
>
> _SC_THREAD_STACK_MIN,
>
> _SC_THREAD_THREADS_MAX,
>
> _SC_THREAD_ATTR_STACKADDR,
>
> _SC_THREAD_ATTR_STACKSIZE,
>
> _SC_THREAD_PRIORITY_SCHEDULING,
>
> _SC_THREAD_PRIO_INHERIT,
>
> _SC_THREAD_PRIO_PROTECT,
>
> _SC_THREAD_PROCESS_SHARED,
>
>
> _SC_NPROCESSORS_CONF,
>
> _SC_NPROCESSORS_ONLN,
>
> _SC_PHYS_PAGES,
>
> _SC_AVPHYS_PAGES,
>
> _SC_ATEXIT_MAX,
>
> _SC_PASS_MAX,
>
>
> _SC_XOPEN_VERSION,
>
> _SC_XOPEN_XCU_VERSION,
>
> _SC_XOPEN_UNIX,
>
> _SC_XOPEN_CRYPT,
>
> _SC_XOPEN_ENH_I18N,
>
> _SC_XOPEN_SHM,
>
>
> _SC_2_CHAR_TERM,
>
> _SC_2_C_VERSION,
>
> _SC_2_UPE,
>
>
> _SC_XOPEN_XPG2,
>
> _SC_XOPEN_XPG3,
>
> _SC_XOPEN_XPG4,
>
>
> _SC_CHAR_BIT,
>
> _SC_CHAR_MAX,
>
> _SC_CHAR_MIN,
>
> _SC_INT_MAX,
>
> _SC_INT_MIN,
>
> _SC_LONG_BIT,
>
> _SC_WORD_BIT,
>
> _SC_MB_LEN_MAX,
>
> _SC_NZERO,
>
> _SC_SSIZE_MAX,
>
> _SC_SCHAR_MAX,
>
> _SC_SCHAR_MIN,
>
> _SC_SHRT_MAX,
>
> _SC_SHRT_MIN,
>
> _SC_UCHAR_MAX,
>
> _SC_UINT_MAX,
>
> _SC_ULONG_MAX,
>
> _SC_USHRT_MAX,
>
>
> _SC_NL_ARGMAX,
>
> _SC_NL_LANGMAX,
>
> _SC_NL_MSGMAX,
>
> _SC_NL_NMAX,
>
> _SC_NL_SETMAX,
>
> _SC_NL_TEXTMAX,
>
>
> _SC_XBS5_ILP32_OFF32,
>
> _SC_XBS5_ILP32_OFFBIG,
>
> _SC_XBS5_LP64_OFF64,
>
> _SC_XBS5_LPBIG_OFFBIG,
>
>
> _SC_XOPEN_LEGACY,
>
> _SC_XOPEN_REALTIME,
>
> _SC_XOPEN_REALTIME_THREADS,
>
>
> _SC_ADVISORY_INFO,
>
> _SC_BARRIERS,
>
> _SC_BASE,
>
> _SC_C_LANG_SUPPORT,
>
> _SC_C_LANG_SUPPORT_R,
>
> _SC_CLOCK_SELECTION,
>
> _SC_CPUTIME,
>
> _SC_THREAD_CPUTIME,
>
> _SC_DEVICE_IO,
>
> _SC_DEVICE_SPECIFIC,
>
> _SC_DEVICE_SPECIFIC_R,
>
> _SC_FD_MGMT,
>
> _SC_FIFO,
>
> _SC_PIPE,
>
> _SC_FILE_ATTRIBUTES,
>
> _SC_FILE_LOCKING,
>
> _SC_FILE_SYSTEM,
>
> _SC_MONOTONIC_CLOCK,
>
> _SC_MULTI_PROCESS,
>
> _SC_SINGLE_PROCESS,
>
> _SC_NETWORKING,
>
> _SC_READER_WRITER_LOCKS,
>
> _SC_SPIN_LOCKS,
>
> _SC_REGEXP,
>
> _SC_REGEX_VERSION,
>
> _SC_SHELL,
>
> _SC_SIGNALS,
>
> _SC_SPAWN,
>
> _SC_SPORADIC_SERVER,
>
> _SC_THREAD_SPORADIC_SERVER,
>
> _SC_SYSTEM_DATABASE,
>
> _SC_SYSTEM_DATABASE_R,
>
> _SC_TIMEOUTS,
>
> _SC_TYPED_MEMORY_OBJECTS,
>
> _SC_USER_GROUPS,
>
> _SC_USER_GROUPS_R,
>
> _SC_2_PBS,
>
> _SC_2_PBS_ACCOUNTING,
>
> _SC_2_PBS_LOCATE,
>
> _SC_2_PBS_MESSAGE,
>
> _SC_2_PBS_TRACK,
>
> _SC_SYMLOOP_MAX,
>
> _SC_STREAMS,
>
> _SC_2_PBS_CHECKPOINT,
>
>
> _SC_V6_ILP32_OFF32,
>
> _SC_V6_ILP32_OFFBIG,
>
> _SC_V6_LP64_OFF64,
>
> _SC_V6_LPBIG_OFFBIG,
>
>
> _SC_HOST_NAME_MAX,
>
> _SC_TRACE,
>
> _SC_TRACE_EVENT_FILTER,
>
> _SC_TRACE_INHERIT,
>
> _SC_TRACE_LOG,
>
>
> _SC_LEVEL1_ICACHE_SIZE,
>
> _SC_LEVEL1_ICACHE_ASSOC,
>
> _SC_LEVEL1_ICACHE_LINESIZE,
>
> _SC_LEVEL1_DCACHE_SIZE,
>
> _SC_LEVEL1_DCACHE_ASSOC,
>
> _SC_LEVEL1_DCACHE_LINESIZE,
>
> _SC_LEVEL2_CACHE_SIZE,
>
> _SC_LEVEL2_CACHE_ASSOC,
>
> _SC_LEVEL2_CACHE_LINESIZE,
>
> _SC_LEVEL3_CACHE_SIZE,
>
> _SC_LEVEL3_CACHE_ASSOC,
>
> _SC_LEVEL3_CACHE_LINESIZE,
>
> _SC_LEVEL4_CACHE_SIZE,
>
> _SC_LEVEL4_CACHE_ASSOC,
>
> _SC_LEVEL4_CACHE_LINESIZE,
>
>
>
> _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
>
> _SC_RAW_SOCKETS,
>
>
> _SC_V7_ILP32_OFF32,
>
> _SC_V7_ILP32_OFFBIG,
>
> _SC_V7_LP64_OFF64,
>
> _SC_V7_LPBIG_OFFBIG,
>
>
> _SC_SS_REPL_MAX,
>
>
> _SC_TRACE_EVENT_NAME_MAX,
>
> _SC_TRACE_NAME_MAX,
>
> _SC_TRACE_SYS_MAX,
>
> _SC_TRACE_USER_EVENT_MAX,
>
>
> _SC_XOPEN_STREAMS,
>
>
> _SC_THREAD_ROBUST_PRIO_INHERIT,
>
> _SC_THREAD_ROBUST_PRIO_PROTECT
>
> };
>
>
>enum
> {
> _CS_PATH,
>
>
> _CS_V6_WIDTH_RESTRICTED_ENVS,
>
>
>
> _CS_GNU_LIBC_VERSION,
>
> _CS_GNU_LIBPTHREAD_VERSION,
>
>
> _CS_V5_WIDTH_RESTRICTED_ENVS,
>
>
>
> _CS_V7_WIDTH_RESTRICTED_ENVS,
>
>
>
> _CS_LFS_CFLAGS = 1000,
>
> _CS_LFS_LDFLAGS,
>
> _CS_LFS_LIBS,
>
> _CS_LFS_LINTFLAGS,
>
> _CS_LFS64_CFLAGS,
>
> _CS_LFS64_LDFLAGS,
>
> _CS_LFS64_LIBS,
>
> _CS_LFS64_LINTFLAGS,
>
>
> _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
>
> _CS_XBS5_ILP32_OFF32_LDFLAGS,
>
> _CS_XBS5_ILP32_OFF32_LIBS,
>
> _CS_XBS5_ILP32_OFF32_LINTFLAGS,
>
> _CS_XBS5_ILP32_OFFBIG_CFLAGS,
>
> _CS_XBS5_ILP32_OFFBIG_LDFLAGS,
>
> _CS_XBS5_ILP32_OFFBIG_LIBS,
>
> _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
>
> _CS_XBS5_LP64_OFF64_CFLAGS,
>
> _CS_XBS5_LP64_OFF64_LDFLAGS,
>
> _CS_XBS5_LP64_OFF64_LIBS,
>
> _CS_XBS5_LP64_OFF64_LINTFLAGS,
>
> _CS_XBS5_LPBIG_OFFBIG_CFLAGS,
>
> _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
>
> _CS_XBS5_LPBIG_OFFBIG_LIBS,
>
> _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
>
>
> _CS_POSIX_V6_ILP32_OFF32_CFLAGS,
>
> _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
>
> _CS_POSIX_V6_ILP32_OFF32_LIBS,
>
> _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
>
> _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
>
> _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
>
> _CS_POSIX_V6_ILP32_OFFBIG_LIBS,
>
> _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
>
> _CS_POSIX_V6_LP64_OFF64_CFLAGS,
>
> _CS_POSIX_V6_LP64_OFF64_LDFLAGS,
>
> _CS_POSIX_V6_LP64_OFF64_LIBS,
>
> _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
>
> _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
>
> _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
>
> _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
>
> _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
>
>
> _CS_POSIX_V7_ILP32_OFF32_CFLAGS,
>
> _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
>
> _CS_POSIX_V7_ILP32_OFF32_LIBS,
>
> _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
>
> _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
>
> _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
>
> _CS_POSIX_V7_ILP32_OFFBIG_LIBS,
>
> _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
>
> _CS_POSIX_V7_LP64_OFF64_CFLAGS,
>
> _CS_POSIX_V7_LP64_OFF64_LDFLAGS,
>
> _CS_POSIX_V7_LP64_OFF64_LIBS,
>
> _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
>
> _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
>
> _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
>
> _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
>
> _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
>
>
> _CS_V6_ENV,
>
> _CS_V7_ENV
>
> };
># 610 "/usr/include/unistd.h" 2 3 4
>
>
>extern long int pathconf (const char *__path, int __name)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern long int fpathconf (int __fd, int __name) throw ();
>
>
>extern long int sysconf (int __name) throw ();
>
>
>
>extern size_t confstr (int __name, char *__buf, size_t __len) throw ();
>
>
>
>
>extern __pid_t getpid (void) throw ();
>
>
>extern __pid_t getppid (void) throw ();
>
>
>
>
>extern __pid_t getpgrp (void) throw ();
># 646 "/usr/include/unistd.h" 3 4
>extern __pid_t __getpgid (__pid_t __pid) throw ();
>
>extern __pid_t getpgid (__pid_t __pid) throw ();
>
>
>
>
>
>
>extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
># 672 "/usr/include/unistd.h" 3 4
>extern int setpgrp (void) throw ();
># 689 "/usr/include/unistd.h" 3 4
>extern __pid_t setsid (void) throw ();
>
>
>
>extern __pid_t getsid (__pid_t __pid) throw ();
>
>
>
>extern __uid_t getuid (void) throw ();
>
>
>extern __uid_t geteuid (void) throw ();
>
>
>extern __gid_t getgid (void) throw ();
>
>
>extern __gid_t getegid (void) throw ();
>
>
>
>
>extern int getgroups (int __size, __gid_t __list[]) throw () ;
>
>
>
>extern int group_member (__gid_t __gid) throw ();
>
>
>
>
>
>
>extern int setuid (__uid_t __uid) throw () ;
>
>
>
>
>extern int setreuid (__uid_t __ruid, __uid_t __euid) throw () ;
>
>
>
>
>extern int seteuid (__uid_t __uid) throw () ;
>
>
>
>
>
>
>extern int setgid (__gid_t __gid) throw () ;
>
>
>
>
>extern int setregid (__gid_t __rgid, __gid_t __egid) throw () ;
>
>
>
>
>extern int setegid (__gid_t __gid) throw () ;
>
>
>
>
>
>extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
> throw ();
>
>
>
>extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
> throw ();
>
>
>
>extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
> throw () ;
>
>
>
>extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
> throw () ;
>
>
>
>
>
>
>extern __pid_t fork (void) throw ();
>
>
>
>
>
>
>
>extern __pid_t vfork (void) throw ();
>
>
>
>
>
>extern char *ttyname (int __fd) throw ();
>
>
>
>extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
> throw () __attribute__ ((__nonnull__ (2))) ;
>
>
>
>extern int isatty (int __fd) throw ();
>
>
>
>
>
>extern int ttyslot (void) throw ();
>
>
>
>
>extern int link (const char *__from, const char *__to)
> throw () __attribute__ ((__nonnull__ (1, 2))) ;
>
>
>
>
>extern int linkat (int __fromfd, const char *__from, int __tofd,
> const char *__to, int __flags)
> throw () __attribute__ ((__nonnull__ (2, 4))) ;
>
>
>
>
>extern int symlink (const char *__from, const char *__to)
> throw () __attribute__ ((__nonnull__ (1, 2))) ;
>
>
>
>
>extern ssize_t readlink (const char *__restrict __path,
> char *__restrict __buf, size_t __len)
> throw () __attribute__ ((__nonnull__ (1, 2))) ;
>
>
>
>
>extern int symlinkat (const char *__from, int __tofd,
> const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) ;
>
>
>extern ssize_t readlinkat (int __fd, const char *__restrict __path,
> char *__restrict __buf, size_t __len)
> throw () __attribute__ ((__nonnull__ (2, 3))) ;
>
>
>
>extern int unlink (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int unlinkat (int __fd, const char *__name, int __flag)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern int rmdir (const char *__path) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern __pid_t tcgetpgrp (int __fd) throw ();
>
>
>extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();
>
>
>
>
>
>
>extern char *getlogin (void);
>
>
>
>
>
>
>
>extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int setlogin (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
># 893 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/getopt.h" 1 3 4
># 48 "/usr/include/getopt.h" 3 4
>extern "C" {
># 57 "/usr/include/getopt.h" 3 4
>extern char *optarg;
># 71 "/usr/include/getopt.h" 3 4
>extern int optind;
>
>
>
>
>extern int opterr;
>
>
>
>extern int optopt;
># 150 "/usr/include/getopt.h" 3 4
>extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
> throw ();
># 185 "/usr/include/getopt.h" 3 4
>}
># 894 "/usr/include/unistd.h" 2 3 4
>
>
>
>
>
>
>
>extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sethostname (const char *__name, size_t __len)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern int sethostid (long int __id) throw () ;
>
>
>
>
>
>extern int getdomainname (char *__name, size_t __len)
> throw () __attribute__ ((__nonnull__ (1))) ;
>extern int setdomainname (const char *__name, size_t __len)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern int vhangup (void) throw ();
>
>
>extern int revoke (const char *__file) throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>
>extern int profil (unsigned short int *__sample_buffer, size_t __size,
> size_t __offset, unsigned int __scale)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int acct (const char *__name) throw ();
>
>
>
>extern char *getusershell (void) throw ();
>extern void endusershell (void) throw ();
>extern void setusershell (void) throw ();
>
>
>
>
>
>extern int daemon (int __nochdir, int __noclose) throw () ;
>
>
>
>
>
>
>extern int chroot (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int fsync (int __fd);
>
>
>
>
>
>extern int syncfs (int __fd) throw ();
>
>
>
>
>
>
>extern long int gethostid (void);
>
>
>extern void sync (void) throw ();
>
>
>
>
>
>extern int getpagesize (void) throw () __attribute__ ((__const__));
>
>
>
>
>extern int getdtablesize (void) throw ();
># 1015 "/usr/include/unistd.h" 3 4
>extern int truncate (const char *__file, __off_t __length)
> throw () __attribute__ ((__nonnull__ (1))) ;
># 1027 "/usr/include/unistd.h" 3 4
>extern int truncate64 (const char *__file, __off64_t __length)
> throw () __attribute__ ((__nonnull__ (1))) ;
># 1038 "/usr/include/unistd.h" 3 4
>extern int ftruncate (int __fd, __off_t __length) throw () ;
># 1048 "/usr/include/unistd.h" 3 4
>extern int ftruncate64 (int __fd, __off64_t __length) throw () ;
># 1059 "/usr/include/unistd.h" 3 4
>extern int brk (void *__addr) throw () ;
>
>
>
>
>
>extern void *sbrk (intptr_t __delta) throw ();
># 1080 "/usr/include/unistd.h" 3 4
>extern long int syscall (long int __sysno, ...) throw ();
># 1103 "/usr/include/unistd.h" 3 4
>extern int lockf (int __fd, int __cmd, __off_t __len) ;
># 1113 "/usr/include/unistd.h" 3 4
>extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
># 1134 "/usr/include/unistd.h" 3 4
>extern int fdatasync (int __fildes);
>
>
>
>
>
>
>
>extern char *crypt (const char *__key, const char *__salt)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern void encrypt (char *__block, int __edflag) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern void swab (const void *__restrict __from, void *__restrict __to,
> ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
># 1172 "/usr/include/unistd.h" 3 4
>}
># 78 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 2 3 4
># 45 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/config/select_platform_config.hpp" 1 3 4
># 50 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/config/platform/linux.hpp" 1 3 4
># 15 "/usr/include/boost/config/platform/linux.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstdlib" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstdlib" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstdlib" 3
># 16 "/usr/include/boost/config/platform/linux.hpp" 2 3 4
># 74 "/usr/include/boost/config/platform/linux.hpp" 3 4
># 1 "/usr/include/boost/config/posix_features.hpp" 1 3 4
># 75 "/usr/include/boost/config/platform/linux.hpp" 2 3 4
># 54 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/config/suffix.hpp" 1 3 4
># 34 "/usr/include/boost/config/suffix.hpp" 3 4
> 
># 35 "/usr/include/boost/config/suffix.hpp" 3
># 482 "/usr/include/boost/config/suffix.hpp" 3
>namespace boost{
>
> __extension__ typedef long long long_long_type;
> __extension__ typedef unsigned long long ulong_long_type;
>
>
>
>
>}
>
>
>
>namespace boost{
>
> __extension__ typedef __int128 int128_type;
> __extension__ typedef unsigned __int128 uint128_type;
>
>
>
>
>}
># 58 "/usr/include/boost/config.hpp" 2 3 4
># 19 "/usr/include/boost/circular_buffer_fwd.hpp" 2 3 4
>
># 1 "/usr/include/c++/4.8.2/memory" 1 3 4
># 46 "/usr/include/c++/4.8.2/memory" 3 4
> 
># 47 "/usr/include/c++/4.8.2/memory" 3
># 66 "/usr/include/c++/4.8.2/memory" 3
># 1 "/usr/include/c++/4.8.2/bits/stl_tempbuf.h" 1 3
># 62 "/usr/include/c++/4.8.2/bits/stl_tempbuf.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 83 "/usr/include/c++/4.8.2/bits/stl_tempbuf.h" 3
> template<typename _Tp>
> pair<_Tp*, ptrdiff_t>
> get_temporary_buffer(ptrdiff_t __len) noexcept
> {
> const ptrdiff_t __max =
> __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
> if (__len > __max)
> __len = __max;
>
> while (__len > 0)
> {
> _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
> std::nothrow));
> if (__tmp != 0)
> return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
> __len /= 2;
> }
> return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
> }
># 110 "/usr/include/c++/4.8.2/bits/stl_tempbuf.h" 3
> template<typename _Tp>
> inline void
> return_temporary_buffer(_Tp* __p)
> { ::operator delete(__p, std::nothrow); }
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Tp>
> class _Temporary_buffer
> {
>
> 
>
> public:
> typedef _Tp value_type;
> typedef value_type* pointer;
> typedef pointer iterator;
> typedef ptrdiff_t size_type;
>
> protected:
> size_type _M_original_len;
> size_type _M_len;
> pointer _M_buffer;
>
> public:
>
> size_type
> size() const
> { return _M_len; }
>
>
> size_type
> requested_size() const
> { return _M_original_len; }
>
>
> iterator
> begin()
> { return _M_buffer; }
>
>
> iterator
> end()
> { return _M_buffer + _M_len; }
>
>
>
>
>
> _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
>
> ~_Temporary_buffer()
> {
> std::_Destroy(_M_buffer, _M_buffer + _M_len);
> std::return_temporary_buffer(_M_buffer);
> }
>
> private:
>
> _Temporary_buffer(const _Temporary_buffer&);
>
> void
> operator=(const _Temporary_buffer&);
> };
>
>
> template<bool>
> struct __uninitialized_construct_buf_dispatch
> {
> template<typename _Pointer, typename _ForwardIterator>
> static void
> __ucr(_Pointer __first, _Pointer __last,
> _ForwardIterator __seed)
> {
> if(__first == __last)
> return;
>
> _Pointer __cur = __first;
> try
> {
> std::_Construct(std::__addressof(*__first),
> std::move(*__seed));
> _Pointer __prev = __cur;
> ++__cur;
> for(; __cur != __last; ++__cur, ++__prev)
> std::_Construct(std::__addressof(*__cur),
> std::move(*__prev));
> *__seed = std::move(*__prev);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_construct_buf_dispatch<true>
> {
> template<typename _Pointer, typename _ForwardIterator>
> static void
> __ucr(_Pointer, _Pointer, _ForwardIterator) { }
> };
># 229 "/usr/include/c++/4.8.2/bits/stl_tempbuf.h" 3
> template<typename _Pointer, typename _ForwardIterator>
> inline void
> __uninitialized_construct_buf(_Pointer __first, _Pointer __last,
> _ForwardIterator __seed)
> {
> typedef typename std::iterator_traits<_Pointer>::value_type
> _ValueType;
>
> std::__uninitialized_construct_buf_dispatch<
> __has_trivial_constructor(_ValueType)>::
> __ucr(__first, __last, __seed);
> }
>
> template<typename _ForwardIterator, typename _Tp>
> _Temporary_buffer<_ForwardIterator, _Tp>::
> _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
> : _M_original_len(std::distance(__first, __last)),
> _M_len(0), _M_buffer(0)
> {
> try
> {
> std::pair<pointer, size_type> __p(std::get_temporary_buffer<
> value_type>(_M_original_len));
> _M_buffer = __p.first;
> _M_len = __p.second;
> if (_M_buffer)
> std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len,
> __first);
> }
> catch(...)
> {
> std::return_temporary_buffer(_M_buffer);
> _M_buffer = 0;
> _M_len = 0;
> throw;
> }
> }
>
>
>}
># 67 "/usr/include/c++/4.8.2/memory" 2 3
># 1 "/usr/include/c++/4.8.2/bits/stl_raw_storage_iter.h" 1 3
># 59 "/usr/include/c++/4.8.2/bits/stl_raw_storage_iter.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
> template <class _OutputIterator, class _Tp>
> class raw_storage_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _OutputIterator _M_iter;
>
> public:
> explicit
> raw_storage_iterator(_OutputIterator __x)
> : _M_iter(__x) {}
>
> raw_storage_iterator&
> operator*() { return *this; }
>
> raw_storage_iterator&
> operator=(const _Tp& __element)
> {
> std::_Construct(std::__addressof(*_M_iter), __element);
> return *this;
> }
>
> raw_storage_iterator<_OutputIterator, _Tp>&
> operator++()
> {
> ++_M_iter;
> return *this;
> }
>
> raw_storage_iterator<_OutputIterator, _Tp>
> operator++(int)
> {
> raw_storage_iterator<_OutputIterator, _Tp> __tmp = *this;
> ++_M_iter;
> return __tmp;
> }
> };
>
>
>}
># 68 "/usr/include/c++/4.8.2/memory" 2 3
>
>
>
># 1 "/usr/include/c++/4.8.2/typeinfo" 1 3
># 32 "/usr/include/c++/4.8.2/typeinfo" 3
> 
># 33 "/usr/include/c++/4.8.2/typeinfo" 3
>
>
>
>
>
>
>#pragma GCC visibility push(default)
>
>extern "C++" {
>
>namespace __cxxabiv1
>{
> class __class_type_info;
>}
># 80 "/usr/include/c++/4.8.2/typeinfo" 3
>namespace std
>{
>
>
>
>
>
>
> class type_info
> {
> public:
>
>
>
>
> virtual ~type_info();
>
>
>
> const char* name() const noexcept
> { return __name[0] == '*' ? __name + 1 : __name; }
># 115 "/usr/include/c++/4.8.2/typeinfo" 3
> bool before(const type_info& __arg) const noexcept
> { return (__name[0] == '*' && __arg.__name[0] == '*')
> ? __name < __arg.__name
> : __builtin_strcmp (__name, __arg.__name) < 0; }
>
> bool operator==(const type_info& __arg) const noexcept
> {
> return ((__name == __arg.__name)
> || (__name[0] != '*' &&
> __builtin_strcmp (__name, __arg.__name) == 0));
> }
># 136 "/usr/include/c++/4.8.2/typeinfo" 3
> bool operator!=(const type_info& __arg) const noexcept
> { return !operator==(__arg); }
>
>
> size_t hash_code() const noexcept
> {
>
> return _Hash_bytes(name(), __builtin_strlen(name()),
> static_cast<size_t>(0xc70f6907UL));
>
>
>
> }
>
>
>
> virtual bool __is_pointer_p() const;
>
>
> virtual bool __is_function_p() const;
>
>
>
>
>
>
>
> virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
> unsigned __outer) const;
>
>
> virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
> void **__obj_ptr) const;
>
> protected:
> const char *__name;
>
> explicit type_info(const char *__n): __name(__n) { }
>
> private:
>
> type_info& operator=(const type_info&);
> type_info(const type_info&);
> };
>
>
>
>
>
>
>
> class bad_cast : public exception
> {
> public:
> bad_cast() noexcept { }
>
>
>
> virtual ~bad_cast() noexcept;
>
>
> virtual const char* what() const noexcept;
> };
>
>
>
>
>
> class bad_typeid : public exception
> {
> public:
> bad_typeid () noexcept { }
>
>
>
> virtual ~bad_typeid() noexcept;
>
>
> virtual const char* what() const noexcept;
> };
>}
>
>}
>
>#pragma GCC visibility pop
># 72 "/usr/include/c++/4.8.2/memory" 2 3
>
>
># 1 "/usr/include/c++/4.8.2/ext/concurrence.h" 1 3
># 32 "/usr/include/c++/4.8.2/ext/concurrence.h" 3
> 
># 33 "/usr/include/c++/4.8.2/ext/concurrence.h" 3
>
>
>
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> enum _Lock_policy { _S_single, _S_mutex, _S_atomic };
>
>
>
> static const _Lock_policy __default_lock_policy =
>
>
>
> _S_atomic;
># 67 "/usr/include/c++/4.8.2/ext/concurrence.h" 3
> class __concurrence_lock_error : public std::exception
> {
> public:
> virtual char const*
> what() const throw()
> { return "__gnu_cxx::__concurrence_lock_error"; }
> };
>
> class __concurrence_unlock_error : public std::exception
> {
> public:
> virtual char const*
> what() const throw()
> { return "__gnu_cxx::__concurrence_unlock_error"; }
> };
>
> class __concurrence_broadcast_error : public std::exception
> {
> public:
> virtual char const*
> what() const throw()
> { return "__gnu_cxx::__concurrence_broadcast_error"; }
> };
>
> class __concurrence_wait_error : public std::exception
> {
> public:
> virtual char const*
> what() const throw()
> { return "__gnu_cxx::__concurrence_wait_error"; }
> };
>
>
> inline void
> __throw_concurrence_lock_error()
> { (throw (__concurrence_lock_error())); }
>
> inline void
> __throw_concurrence_unlock_error()
> { (throw (__concurrence_unlock_error())); }
>
>
> inline void
> __throw_concurrence_broadcast_error()
> { (throw (__concurrence_broadcast_error())); }
>
> inline void
> __throw_concurrence_wait_error()
> { (throw (__concurrence_wait_error())); }
>
>
> class __mutex
> {
> private:
>
> __gthread_mutex_t _M_mutex = { { 0, 0, 0, 0, 0, 0, 0, { 0, 0 } } };
>
>
>
>
> __mutex(const __mutex&);
> __mutex& operator=(const __mutex&);
>
> public:
> __mutex()
> {
>
>
>
>
> }
># 147 "/usr/include/c++/4.8.2/ext/concurrence.h" 3
> void lock()
> {
>
> if (__gthread_active_p())
> {
> if (__gthread_mutex_lock(&_M_mutex) != 0)
> __throw_concurrence_lock_error();
> }
>
> }
>
> void unlock()
> {
>
> if (__gthread_active_p())
> {
> if (__gthread_mutex_unlock(&_M_mutex) != 0)
> __throw_concurrence_unlock_error();
> }
>
> }
>
> __gthread_mutex_t* gthread_mutex(void)
> { return &_M_mutex; }
> };
>
> class __recursive_mutex
> {
> private:
>
> __gthread_recursive_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, 0, { 0, 0 } } };
>
>
>
>
> __recursive_mutex(const __recursive_mutex&);
> __recursive_mutex& operator=(const __recursive_mutex&);
>
> public:
> __recursive_mutex()
> {
>
>
>
>
> }
># 202 "/usr/include/c++/4.8.2/ext/concurrence.h" 3
> void lock()
> {
>
> if (__gthread_active_p())
> {
> if (__gthread_recursive_mutex_lock(&_M_mutex) != 0)
> __throw_concurrence_lock_error();
> }
>
> }
>
> void unlock()
> {
>
> if (__gthread_active_p())
> {
> if (__gthread_recursive_mutex_unlock(&_M_mutex) != 0)
> __throw_concurrence_unlock_error();
> }
>
> }
>
> __gthread_recursive_mutex_t* gthread_recursive_mutex(void)
> { return &_M_mutex; }
> };
>
>
>
>
> class __scoped_lock
> {
> public:
> typedef __mutex __mutex_type;
>
> private:
> __mutex_type& _M_device;
>
> __scoped_lock(const __scoped_lock&);
> __scoped_lock& operator=(const __scoped_lock&);
>
> public:
> explicit __scoped_lock(__mutex_type& __name) : _M_device(__name)
> { _M_device.lock(); }
>
> ~__scoped_lock() throw()
> { _M_device.unlock(); }
> };
>
>
> class __cond
> {
> private:
>
> __gthread_cond_t _M_cond = { { 0, 0, 0, 0, 0, (void *) 0, 0, 0 } };
>
>
>
>
> __cond(const __cond&);
> __cond& operator=(const __cond&);
>
> public:
> __cond()
> {
>
>
>
>
> }
># 280 "/usr/include/c++/4.8.2/ext/concurrence.h" 3
> void broadcast()
> {
>
> if (__gthread_active_p())
> {
> if (__gthread_cond_broadcast(&_M_cond) != 0)
> __throw_concurrence_broadcast_error();
> }
>
> }
>
> void wait(__mutex *mutex)
> {
>
> {
> if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) != 0)
> __throw_concurrence_wait_error();
> }
>
> }
>
> void wait_recursive(__recursive_mutex *mutex)
> {
>
> {
> if (__gthread_cond_wait_recursive(&_M_cond,
> mutex->gthread_recursive_mutex())
> != 0)
> __throw_concurrence_wait_error();
> }
>
> }
> };
>
>
>
>}
># 75 "/usr/include/c++/4.8.2/memory" 2 3
>
>
># 1 "/usr/include/c++/4.8.2/bits/uses_allocator.h" 1 3
># 34 "/usr/include/c++/4.8.2/bits/uses_allocator.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> struct allocator_arg_t { };
>
> constexpr allocator_arg_t allocator_arg = allocator_arg_t();
>
>template<typename _Tp> class __has_allocator_type_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::allocator_type>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_allocator_type : integral_constant<bool, __has_allocator_type_helper <typename remove_cv<_Tp>::type>::value> { };
>
> template<typename _Tp, typename _Alloc,
> bool = __has_allocator_type<_Tp>::value>
> struct __uses_allocator_helper
> : public false_type { };
>
> template<typename _Tp, typename _Alloc>
> struct __uses_allocator_helper<_Tp, _Alloc, true>
> : public integral_constant<bool, is_convertible<_Alloc,
> typename _Tp::allocator_type>::value>
> { };
>
>
> template<typename _Tp, typename _Alloc>
> struct uses_allocator
> : public integral_constant<bool,
> __uses_allocator_helper<_Tp, _Alloc>::value>
> { };
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> struct __uses_allocator_arg
> : is_constructible<_Tp, _Alloc, _Args...>
> { static_assert( uses_allocator<_Tp, _Alloc>::value, "uses allocator" ); };
>
> struct __uses_alloc_base { };
> struct __uses_alloc0 : __uses_alloc_base
> { struct _Anything { _Anything(...) { } } _M_a; };
> template<typename _Alloc>
> struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; };
> template<typename _Alloc>
> struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; };
>
> template<bool, typename _Alloc, typename... _Args>
> struct __uses_alloc;
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> struct __uses_alloc<true, _Tp, _Alloc, _Args...>
> : conditional<
> is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value,
> __uses_alloc1<_Alloc>,
> __uses_alloc2<_Alloc>>::type
> { };
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> struct __uses_alloc<false, _Tp, _Alloc, _Args...>
> : __uses_alloc0 { };
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> struct __uses_alloc_impl
> : __uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...>
> { };
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> __uses_alloc_impl<_Tp, _Alloc, _Args...>
> __use_alloc(const _Alloc& __a)
> {
> __uses_alloc_impl<_Tp, _Alloc, _Args...> __ret;
> __ret._M_a = &__a;
> return __ret;
> }
>
>
>}
># 78 "/usr/include/c++/4.8.2/memory" 2 3
>
># 1 "/usr/include/c++/4.8.2/functional" 1 3
># 46 "/usr/include/c++/4.8.2/functional" 3
> 
># 47 "/usr/include/c++/4.8.2/functional" 3
># 55 "/usr/include/c++/4.8.2/functional" 3
># 1 "/usr/include/c++/4.8.2/tuple" 1 3
># 32 "/usr/include/c++/4.8.2/tuple" 3
> 
># 33 "/usr/include/c++/4.8.2/tuple" 3
>
>
>
>
>
>
># 1 "/usr/include/c++/4.8.2/array" 1 3
># 32 "/usr/include/c++/4.8.2/array" 3
> 
># 33 "/usr/include/c++/4.8.2/array" 3
>
>
>
>
>
># 1 "/usr/include/c++/4.8.2/stdexcept" 1 3
># 36 "/usr/include/c++/4.8.2/stdexcept" 3
> 
># 37 "/usr/include/c++/4.8.2/stdexcept" 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 55 "/usr/include/c++/4.8.2/stdexcept" 3
> class logic_error : public exception
> {
> string _M_msg;
>
> public:
>
> explicit
> logic_error(const string& __arg);
>
> virtual ~logic_error() noexcept;
>
>
>
> virtual const char*
> what() const noexcept;
> };
>
>
>
> class domain_error : public logic_error
> {
> public:
> explicit domain_error(const string& __arg);
> virtual ~domain_error() noexcept;
> };
>
>
> class invalid_argument : public logic_error
> {
> public:
> explicit invalid_argument(const string& __arg);
> virtual ~invalid_argument() noexcept;
> };
>
>
>
> class length_error : public logic_error
> {
> public:
> explicit length_error(const string& __arg);
> virtual ~length_error() noexcept;
> };
>
>
>
> class out_of_range : public logic_error
> {
> public:
> explicit out_of_range(const string& __arg);
> virtual ~out_of_range() noexcept;
> };
>
>
>
>
>
>
> class runtime_error : public exception
> {
> string _M_msg;
>
> public:
>
> explicit
> runtime_error(const string& __arg);
>
> virtual ~runtime_error() noexcept;
>
>
>
> virtual const char*
> what() const noexcept;
> };
>
>
> class range_error : public runtime_error
> {
> public:
> explicit range_error(const string& __arg);
> virtual ~range_error() noexcept;
> };
>
>
> class overflow_error : public runtime_error
> {
> public:
> explicit overflow_error(const string& __arg);
> virtual ~overflow_error() noexcept;
> };
>
>
> class underflow_error : public runtime_error
> {
> public:
> explicit underflow_error(const string& __arg);
> virtual ~underflow_error() noexcept;
> };
>
>
>
>
>}
># 39 "/usr/include/c++/4.8.2/array" 2 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Tp, std::size_t _Nm>
> struct __array_traits
> {
> typedef _Tp _Type[_Nm];
>
> static constexpr _Tp&
> _S_ref(const _Type& __t, std::size_t __n) noexcept
> { return const_cast<_Tp&>(__t[__n]); }
> };
>
> template<typename _Tp>
> struct __array_traits<_Tp, 0>
> {
> struct _Type { };
>
> static constexpr _Tp&
> _S_ref(const _Type&, std::size_t) noexcept
> { return *static_cast<_Tp*>(nullptr); }
> };
># 80 "/usr/include/c++/4.8.2/array" 3
> template<typename _Tp, std::size_t _Nm>
> struct array
> {
> typedef _Tp value_type;
> typedef value_type* pointer;
> typedef const value_type* const_pointer;
> 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;
>
>
> typedef std::__array_traits<_Tp, _Nm> _AT_Type;
> typename _AT_Type::_Type _M_elems;
>
>
>
>
> void
> fill(const value_type& __u)
> { std::fill_n(begin(), size(), __u); }
>
> void
> swap(array& __other)
> noexcept(noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())))
> { std::swap_ranges(begin(), end(), __other.begin()); }
>
>
> iterator
> begin() noexcept
> { return iterator(data()); }
>
> const_iterator
> begin() const noexcept
> { return const_iterator(data()); }
>
> iterator
> end() noexcept
> { return iterator(data() + _Nm); }
>
> const_iterator
> end() const noexcept
> { return const_iterator(data() + _Nm); }
>
> reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(end()); }
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
> reverse_iterator
> rend() noexcept
> { return reverse_iterator(begin()); }
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(begin()); }
>
> const_iterator
> cbegin() const noexcept
> { return const_iterator(data()); }
>
> const_iterator
> cend() const noexcept
> { return const_iterator(data() + _Nm); }
>
> const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
> const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
> constexpr size_type
> size() const noexcept { return _Nm; }
>
> constexpr size_type
> max_size() const noexcept { return _Nm; }
>
> constexpr bool
> empty() const noexcept { return size() == 0; }
>
>
> reference
> operator[](size_type __n)
> { return _AT_Type::_S_ref(_M_elems, __n); }
>
> constexpr const_reference
> operator[](size_type __n) const noexcept
> { return _AT_Type::_S_ref(_M_elems, __n); }
>
> reference
> at(size_type __n)
> {
> if (__n >= _Nm)
> std::__throw_out_of_range(("array::at"));
> return _AT_Type::_S_ref(_M_elems, __n);
> }
>
> constexpr const_reference
> at(size_type __n) const
> {
>
>
> return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
> : (std::__throw_out_of_range(("array::at")),
> _AT_Type::_S_ref(_M_elems, 0));
> }
>
> reference
> front()
> { return *begin(); }
>
> constexpr const_reference
> front() const
> { return _AT_Type::_S_ref(_M_elems, 0); }
>
> reference
> back()
> { return _Nm ? *(end() - 1) : *end(); }
>
> constexpr const_reference
> back() const
> {
> return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
> : _AT_Type::_S_ref(_M_elems, 0);
> }
>
> pointer
> data() noexcept
> { return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); }
>
> const_pointer
> data() const noexcept
> { return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); }
> };
>
>
> 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); }
>
>
> template<typename _Tp, std::size_t _Nm>
> inline void
> swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
> noexcept(noexcept(__one.swap(__two)))
> { __one.swap(__two); }
>
> template<std::size_t _Int, typename _Tp, std::size_t _Nm>
> constexpr _Tp&
> get(array<_Tp, _Nm>& __arr) noexcept
> {
> static_assert(_Int < _Nm, "index is out of bounds");
> return std::__array_traits<_Tp, _Nm>::
> _S_ref(__arr._M_elems, _Int);
> }
>
> template<std::size_t _Int, typename _Tp, std::size_t _Nm>
> constexpr _Tp&&
> get(array<_Tp, _Nm>&& __arr) noexcept
> {
> static_assert(_Int < _Nm, "index is out of bounds");
> return std::move(get<_Int>(__arr));
> }
>
> template<std::size_t _Int, typename _Tp, std::size_t _Nm>
> constexpr const _Tp&
> get(const array<_Tp, _Nm>& __arr) noexcept
> {
> static_assert(_Int < _Nm, "index is out of bounds");
> return std::__array_traits<_Tp, _Nm>::
> _S_ref(__arr._M_elems, _Int);
> }
>
>
>}
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
> template<typename _Tp>
> class tuple_size;
>
> template<typename _Tp, std::size_t _Nm>
> struct tuple_size<std::array<_Tp, _Nm>>
> : public integral_constant<std::size_t, _Nm> { };
>
>
> template<std::size_t _Int, typename _Tp>
> class tuple_element;
>
> template<std::size_t _Int, typename _Tp, std::size_t _Nm>
> struct tuple_element<_Int, std::array<_Tp, _Nm>>
> {
> static_assert(_Int < _Nm, "index is out of bounds");
> typedef _Tp type;
> };
>
>
>}
># 40 "/usr/include/c++/4.8.2/tuple" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>
> template<typename _Tp>
> struct __add_c_ref
> { typedef const _Tp& type; };
>
> template<typename _Tp>
> struct __add_c_ref<_Tp&>
> { typedef _Tp& type; };
>
>
> template<typename _Tp>
> struct __add_ref
> { typedef _Tp& type; };
>
> template<typename _Tp>
> struct __add_ref<_Tp&>
> { typedef _Tp& type; };
>
>
> template<typename _Tp>
> struct __add_r_ref
> { typedef _Tp&& type; };
>
> template<typename _Tp>
> struct __add_r_ref<_Tp&>
> { typedef _Tp& type; };
>
> template<std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal>
> struct _Head_base;
>
> template<std::size_t _Idx, typename _Head>
> struct _Head_base<_Idx, _Head, true>
> : public _Head
> {
> constexpr _Head_base()
> : _Head() { }
>
> constexpr _Head_base(const _Head& __h)
> : _Head(__h) { }
>
> template<typename _UHead, typename = typename
> enable_if<!is_convertible<_UHead,
> __uses_alloc_base>::value>::type>
> constexpr _Head_base(_UHead&& __h)
> : _Head(std::forward<_UHead>(__h)) { }
>
> _Head_base(__uses_alloc0)
> : _Head() { }
>
> template<typename _Alloc>
> _Head_base(__uses_alloc1<_Alloc> __a)
> : _Head(allocator_arg, *__a._M_a) { }
>
> template<typename _Alloc>
> _Head_base(__uses_alloc2<_Alloc> __a)
> : _Head(*__a._M_a) { }
>
> template<typename _UHead>
> _Head_base(__uses_alloc0, _UHead&& __uhead)
> : _Head(std::forward<_UHead>(__uhead)) { }
>
> template<typename _Alloc, typename _UHead>
> _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
> : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
>
> template<typename _Alloc, typename _UHead>
> _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
> : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
>
> static constexpr _Head&
> _M_head(_Head_base& __b) noexcept { return __b; }
>
> static constexpr const _Head&
> _M_head(const _Head_base& __b) noexcept { return __b; }
> };
>
> template<std::size_t _Idx, typename _Head>
> struct _Head_base<_Idx, _Head, false>
> {
> constexpr _Head_base()
> : _M_head_impl() { }
>
> constexpr _Head_base(const _Head& __h)
> : _M_head_impl(__h) { }
>
> template<typename _UHead, typename = typename
> enable_if<!is_convertible<_UHead,
> __uses_alloc_base>::value>::type>
> constexpr _Head_base(_UHead&& __h)
> : _M_head_impl(std::forward<_UHead>(__h)) { }
>
> _Head_base(__uses_alloc0)
> : _M_head_impl() { }
>
> template<typename _Alloc>
> _Head_base(__uses_alloc1<_Alloc> __a)
> : _M_head_impl(allocator_arg, *__a._M_a) { }
>
> template<typename _Alloc>
> _Head_base(__uses_alloc2<_Alloc> __a)
> : _M_head_impl(*__a._M_a) { }
>
> template<typename _UHead>
> _Head_base(__uses_alloc0, _UHead&& __uhead)
> : _M_head_impl(std::forward<_UHead>(__uhead)) { }
>
> template<typename _Alloc, typename _UHead>
> _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
> : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
> { }
>
> template<typename _Alloc, typename _UHead>
> _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
> : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
>
> static constexpr _Head&
> _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
>
> static constexpr const _Head&
> _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
>
> _Head _M_head_impl;
> };
># 183 "/usr/include/c++/4.8.2/tuple" 3
> template<std::size_t _Idx, typename... _Elements>
> struct _Tuple_impl;
>
>
>
>
>
> template<std::size_t _Idx>
> struct _Tuple_impl<_Idx>
> {
> template<std::size_t, typename...> friend class _Tuple_impl;
>
> _Tuple_impl() = default;
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t, const _Alloc&) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t, const _Alloc&, const _Tuple_impl&) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t, const _Alloc&, _Tuple_impl&&) { }
>
> protected:
> void _M_swap(_Tuple_impl&) noexcept { }
> };
>
> template<typename _Tp>
> struct __is_empty_non_tuple : is_empty<_Tp> { };
>
>
> template<typename _El0, typename... _El>
> struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
>
>
> template<typename _Tp>
> using __empty_not_final
> = typename conditional<__is_final(_Tp), false_type,
> __is_empty_non_tuple<_Tp>>::type;
>
>
>
>
>
>
> template<std::size_t _Idx, typename _Head, typename... _Tail>
> struct _Tuple_impl<_Idx, _Head, _Tail...>
> : public _Tuple_impl<_Idx + 1, _Tail...>,
> private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
> {
> template<std::size_t, typename...> friend class _Tuple_impl;
>
> typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
> typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
>
> static constexpr _Head&
> _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
>
> static constexpr const _Head&
> _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
>
> static constexpr _Inherited&
> _M_tail(_Tuple_impl& __t) noexcept { return __t; }
>
> static constexpr const _Inherited&
> _M_tail(const _Tuple_impl& __t) noexcept { return __t; }
>
> constexpr _Tuple_impl()
> : _Inherited(), _Base() { }
>
> explicit
> constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
> : _Inherited(__tail...), _Base(__head) { }
>
> template<typename _UHead, typename... _UTail, typename = typename
> enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
> explicit
> constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
> : _Inherited(std::forward<_UTail>(__tail)...),
> _Base(std::forward<_UHead>(__head)) { }
>
> constexpr _Tuple_impl(const _Tuple_impl&) = default;
>
> constexpr
> _Tuple_impl(_Tuple_impl&& __in)
> noexcept(__and_<is_nothrow_move_constructible<_Head>,
> is_nothrow_move_constructible<_Inherited>>::value)
> : _Inherited(std::move(_M_tail(__in))),
> _Base(std::forward<_Head>(_M_head(__in))) { }
>
> template<typename... _UElements>
> constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
> : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
> _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
>
> template<typename _UHead, typename... _UTails>
> constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
> : _Inherited(std::move
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
> _Base(std::forward<_UHead>
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
> : _Inherited(__tag, __a),
> _Base(__use_alloc<_Head>(__a)) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> const _Head& __head, const _Tail&... __tail)
> : _Inherited(__tag, __a, __tail...),
> _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
>
> template<typename _Alloc, typename _UHead, typename... _UTail,
> typename = typename enable_if<sizeof...(_Tail)
> == sizeof...(_UTail)>::type>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> _UHead&& __head, _UTail&&... __tail)
> : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
> _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
> std::forward<_UHead>(__head)) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> const _Tuple_impl& __in)
> : _Inherited(__tag, __a, _M_tail(__in)),
> _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> _Tuple_impl&& __in)
> : _Inherited(__tag, __a, std::move(_M_tail(__in))),
> _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
> std::forward<_Head>(_M_head(__in))) { }
>
> template<typename _Alloc, typename... _UElements>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> const _Tuple_impl<_Idx, _UElements...>& __in)
> : _Inherited(__tag, __a,
> _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
> _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
> _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
>
> template<typename _Alloc, typename _UHead, typename... _UTails>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
> : _Inherited(__tag, __a, std::move
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
> _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
> std::forward<_UHead>
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
>
> _Tuple_impl&
> operator=(const _Tuple_impl& __in)
> {
> _M_head(*this) = _M_head(__in);
> _M_tail(*this) = _M_tail(__in);
> return *this;
> }
>
> _Tuple_impl&
> operator=(_Tuple_impl&& __in)
> noexcept(__and_<is_nothrow_move_assignable<_Head>,
> is_nothrow_move_assignable<_Inherited>>::value)
> {
> _M_head(*this) = std::forward<_Head>(_M_head(__in));
> _M_tail(*this) = std::move(_M_tail(__in));
> return *this;
> }
>
> template<typename... _UElements>
> _Tuple_impl&
> operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
> {
> _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
> _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);
> return *this;
> }
>
> template<typename _UHead, typename... _UTails>
> _Tuple_impl&
> operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
> {
> _M_head(*this) = std::forward<_UHead>
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
> _M_tail(*this) = std::move
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
> return *this;
> }
>
> protected:
> void
> _M_swap(_Tuple_impl& __in)
> noexcept(noexcept(swap(std::declval<_Head&>(),
> std::declval<_Head&>()))
> && noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
> {
> using std::swap;
> swap(_M_head(*this), _M_head(__in));
> _Inherited::_M_swap(_M_tail(__in));
> }
> };
>
>
> template<typename... _Elements>
> class tuple : public _Tuple_impl<0, _Elements...>
> {
> typedef _Tuple_impl<0, _Elements...> _Inherited;
>
> public:
> constexpr tuple()
> : _Inherited() { }
>
> explicit
> constexpr tuple(const _Elements&... __elements)
> : _Inherited(__elements...) { }
>
> template<typename... _UElements, typename = typename
> enable_if<__and_<is_convertible<_UElements,
> _Elements>...>::value>::type>
> explicit
> constexpr tuple(_UElements&&... __elements)
> : _Inherited(std::forward<_UElements>(__elements)...) { }
>
> constexpr tuple(const tuple&) = default;
>
> constexpr tuple(tuple&&) = default;
>
> template<typename... _UElements, typename = typename
> enable_if<__and_<is_convertible<const _UElements&,
> _Elements>...>::value>::type>
> constexpr tuple(const tuple<_UElements...>& __in)
> : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
> { }
>
> template<typename... _UElements, typename = typename
> enable_if<__and_<is_convertible<_UElements,
> _Elements>...>::value>::type>
> constexpr tuple(tuple<_UElements...>&& __in)
> : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
>
>
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a)
> : _Inherited(__tag, __a) { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> const _Elements&... __elements)
> : _Inherited(__tag, __a, __elements...) { }
>
> template<typename _Alloc, typename... _UElements, typename = typename
> enable_if<sizeof...(_UElements)
> == sizeof...(_Elements)>::type>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> _UElements&&... __elements)
> : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
> { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
> : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
> : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
>
> template<typename _Alloc, typename... _UElements, typename = typename
> enable_if<sizeof...(_UElements)
> == sizeof...(_Elements)>::type>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> const tuple<_UElements...>& __in)
> : _Inherited(__tag, __a,
> static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
> { }
>
> template<typename _Alloc, typename... _UElements, typename = typename
> enable_if<sizeof...(_UElements)
> == sizeof...(_Elements)>::type>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> tuple<_UElements...>&& __in)
> : _Inherited(__tag, __a,
> static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
> { }
>
> tuple&
> operator=(const tuple& __in)
> {
> static_cast<_Inherited&>(*this) = __in;
> return *this;
> }
>
> tuple&
> operator=(tuple&& __in)
> noexcept(is_nothrow_move_assignable<_Inherited>::value)
> {
> static_cast<_Inherited&>(*this) = std::move(__in);
> return *this;
> }
>
> template<typename... _UElements, typename = typename
> enable_if<sizeof...(_UElements)
> == sizeof...(_Elements)>::type>
> tuple&
> operator=(const tuple<_UElements...>& __in)
> {
> static_cast<_Inherited&>(*this) = __in;
> return *this;
> }
>
> template<typename... _UElements, typename = typename
> enable_if<sizeof...(_UElements)
> == sizeof...(_Elements)>::type>
> tuple&
> operator=(tuple<_UElements...>&& __in)
> {
> static_cast<_Inherited&>(*this) = std::move(__in);
> return *this;
> }
>
> void
> swap(tuple& __in)
> noexcept(noexcept(__in._M_swap(__in)))
> { _Inherited::_M_swap(__in); }
> };
>
>
> template<>
> class tuple<>
> {
> public:
> void swap(tuple&) noexcept { }
> };
>
>
>
> template<typename _T1, typename _T2>
> class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
> {
> typedef _Tuple_impl<0, _T1, _T2> _Inherited;
>
> public:
> constexpr tuple()
> : _Inherited() { }
>
> explicit
> constexpr tuple(const _T1& __a1, const _T2& __a2)
> : _Inherited(__a1, __a2) { }
>
> template<typename _U1, typename _U2, typename = typename
> enable_if<__and_<is_convertible<_U1, _T1>,
> is_convertible<_U2, _T2>>::value>::type>
> explicit
> constexpr tuple(_U1&& __a1, _U2&& __a2)
> : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
>
> constexpr tuple(const tuple&) = default;
>
> constexpr tuple(tuple&&) = default;
>
> template<typename _U1, typename _U2, typename = typename
> enable_if<__and_<is_convertible<const _U1&, _T1>,
> is_convertible<const _U2&, _T2>>::value>::type>
> constexpr tuple(const tuple<_U1, _U2>& __in)
> : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
>
> template<typename _U1, typename _U2, typename = typename
> enable_if<__and_<is_convertible<_U1, _T1>,
> is_convertible<_U2, _T2>>::value>::type>
> constexpr tuple(tuple<_U1, _U2>&& __in)
> : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
>
> template<typename _U1, typename _U2, typename = typename
> enable_if<__and_<is_convertible<const _U1&, _T1>,
> is_convertible<const _U2&, _T2>>::value>::type>
> constexpr tuple(const pair<_U1, _U2>& __in)
> : _Inherited(__in.first, __in.second) { }
>
> template<typename _U1, typename _U2, typename = typename
> enable_if<__and_<is_convertible<_U1, _T1>,
> is_convertible<_U2, _T2>>::value>::type>
> constexpr tuple(pair<_U1, _U2>&& __in)
> : _Inherited(std::forward<_U1>(__in.first),
> std::forward<_U2>(__in.second)) { }
>
>
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a)
> : _Inherited(__tag, __a) { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> const _T1& __a1, const _T2& __a2)
> : _Inherited(__tag, __a, __a1, __a2) { }
>
> template<typename _Alloc, typename _U1, typename _U2>
> tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
> : _Inherited(__tag, __a, std::forward<_U1>(__a1),
> std::forward<_U2>(__a2)) { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
> : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
> : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
>
> template<typename _Alloc, typename _U1, typename _U2>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> const tuple<_U1, _U2>& __in)
> : _Inherited(__tag, __a,
> static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
> { }
>
> template<typename _Alloc, typename _U1, typename _U2>
> tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
> : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
> { }
>
> template<typename _Alloc, typename _U1, typename _U2>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> const pair<_U1, _U2>& __in)
> : _Inherited(__tag, __a, __in.first, __in.second) { }
>
> template<typename _Alloc, typename _U1, typename _U2>
> tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
> : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
> std::forward<_U2>(__in.second)) { }
>
> tuple&
> operator=(const tuple& __in)
> {
> static_cast<_Inherited&>(*this) = __in;
> return *this;
> }
>
> tuple&
> operator=(tuple&& __in)
> noexcept(is_nothrow_move_assignable<_Inherited>::value)
> {
> static_cast<_Inherited&>(*this) = std::move(__in);
> return *this;
> }
>
> template<typename _U1, typename _U2>
> tuple&
> operator=(const tuple<_U1, _U2>& __in)
> {
> static_cast<_Inherited&>(*this) = __in;
> return *this;
> }
>
> template<typename _U1, typename _U2>
> tuple&
> operator=(tuple<_U1, _U2>&& __in)
> {
> static_cast<_Inherited&>(*this) = std::move(__in);
> return *this;
> }
>
> template<typename _U1, typename _U2>
> tuple&
> operator=(const pair<_U1, _U2>& __in)
> {
> this->_M_head(*this) = __in.first;
> this->_M_tail(*this)._M_head(*this) = __in.second;
> return *this;
> }
>
> template<typename _U1, typename _U2>
> tuple&
> operator=(pair<_U1, _U2>&& __in)
> {
> this->_M_head(*this) = std::forward<_U1>(__in.first);
> this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
> return *this;
> }
>
> void
> swap(tuple& __in)
> noexcept(noexcept(__in._M_swap(__in)))
> { _Inherited::_M_swap(__in); }
> };
>
>
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element;
>
>
>
>
>
> template<std::size_t __i, typename _Head, typename... _Tail>
> struct tuple_element<__i, tuple<_Head, _Tail...> >
> : tuple_element<__i - 1, tuple<_Tail...> > { };
>
>
>
>
> template<typename _Head, typename... _Tail>
> struct tuple_element<0, tuple<_Head, _Tail...> >
> {
> typedef _Head type;
> };
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element<__i, const _Tp>
> {
> typedef typename
> add_const<typename tuple_element<__i, _Tp>::type>::type type;
> };
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element<__i, volatile _Tp>
> {
> typedef typename
> add_volatile<typename tuple_element<__i, _Tp>::type>::type type;
> };
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element<__i, const volatile _Tp>
> {
> typedef typename
> add_cv<typename tuple_element<__i, _Tp>::type>::type type;
> };
>
>
> template<typename _Tp>
> struct tuple_size;
>
> template<typename _Tp>
> struct tuple_size<const _Tp>
> : public integral_constant<
> typename remove_cv<decltype(tuple_size<_Tp>::value)>::type,
> tuple_size<_Tp>::value> { };
>
> template<typename _Tp>
> struct tuple_size<volatile _Tp>
> : public integral_constant<
> typename remove_cv<decltype(tuple_size<_Tp>::value)>::type,
> tuple_size<_Tp>::value> { };
>
> template<typename _Tp>
> struct tuple_size<const volatile _Tp>
> : public integral_constant<
> typename remove_cv<decltype(tuple_size<_Tp>::value)>::type,
> tuple_size<_Tp>::value> { };
>
>
> template<typename... _Elements>
> struct tuple_size<tuple<_Elements...>>
> : public integral_constant<std::size_t, sizeof...(_Elements)> { };
>
> template<std::size_t __i, typename _Head, typename... _Tail>
> constexpr typename __add_ref<_Head>::type
> __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
> { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
>
> template<std::size_t __i, typename _Head, typename... _Tail>
> constexpr typename __add_c_ref<_Head>::type
> __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
> { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
>
>
>
>
> template<std::size_t __i, typename... _Elements>
> constexpr typename __add_ref<
> typename tuple_element<__i, tuple<_Elements...>>::type
> >::type
> get(tuple<_Elements...>& __t) noexcept
> { return __get_helper<__i>(__t); }
>
> template<std::size_t __i, typename... _Elements>
> constexpr typename __add_c_ref<
> typename tuple_element<__i, tuple<_Elements...>>::type
> >::type
> get(const tuple<_Elements...>& __t) noexcept
> { return __get_helper<__i>(__t); }
>
> template<std::size_t __i, typename... _Elements>
> constexpr typename __add_r_ref<
> typename tuple_element<__i, tuple<_Elements...>>::type
> >::type
> get(tuple<_Elements...>&& __t) noexcept
> { return std::forward<typename tuple_element<__i,
> tuple<_Elements...>>::type&&>(get<__i>(__t)); }
>
>
> template<std::size_t __check_equal_size, std::size_t __i, std::size_t __j,
> typename _Tp, typename _Up>
> struct __tuple_compare;
>
> template<std::size_t __i, std::size_t __j, typename _Tp, typename _Up>
> struct __tuple_compare<0, __i, __j, _Tp, _Up>
> {
> static constexpr 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 constexpr 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<std::size_t __i, typename _Tp, typename _Up>
> struct __tuple_compare<0, __i, __i, _Tp, _Up>
> {
> static constexpr bool
> __eq(const _Tp&, const _Up&) { return true; }
>
> static constexpr bool
> __less(const _Tp&, const _Up&) { return false; }
> };
>
> template<typename... _TElements, typename... _UElements>
> constexpr bool
> operator==(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> {
> typedef tuple<_TElements...> _Tp;
> typedef tuple<_UElements...> _Up;
> return bool(__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
> 0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
> }
>
> template<typename... _TElements, typename... _UElements>
> constexpr bool
> operator<(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> {
> typedef tuple<_TElements...> _Tp;
> typedef tuple<_UElements...> _Up;
> return bool(__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
> 0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
> }
>
> template<typename... _TElements, typename... _UElements>
> inline constexpr bool
> operator!=(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> { return !(__t == __u); }
>
> template<typename... _TElements, typename... _UElements>
> inline constexpr bool
> operator>(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> { return __u < __t; }
>
> template<typename... _TElements, typename... _UElements>
> inline constexpr bool
> operator<=(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> { return !(__u < __t); }
>
> template<typename... _TElements, typename... _UElements>
> inline constexpr bool
> operator>=(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> { return !(__t < __u); }
>
>
> template<typename... _Elements>
> constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
> make_tuple(_Elements&&... __args)
> {
> typedef tuple<typename __decay_and_strip<_Elements>::__type...>
> __result_type;
> return __result_type(std::forward<_Elements>(__args)...);
> }
>
> template<typename... _Elements>
> tuple<_Elements&&...>
> forward_as_tuple(_Elements&&... __args) noexcept
> { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
>
> template<typename>
> struct __is_tuple_like_impl : false_type
> { };
>
> template<typename... _Tps>
> struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
> { };
>
> template<typename _T1, typename _T2>
> struct __is_tuple_like_impl<pair<_T1, _T2>> : true_type
> { };
>
> template<typename _Tp, std::size_t _Nm>
> struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type
> { };
>
>
> template<typename _Tp>
> struct __is_tuple_like
> : public __is_tuple_like_impl<typename std::remove_cv
> <typename std::remove_reference<_Tp>::type>::type>::type
> { };
>
>
>
> template<std::size_t... _Indexes>
> struct _Index_tuple
> {
> typedef _Index_tuple<_Indexes..., sizeof...(_Indexes)> __next;
> };
>
>
> template<std::size_t _Num>
> struct _Build_index_tuple
> {
> typedef typename _Build_index_tuple<_Num - 1>::__type::__next __type;
> };
>
> template<>
> struct _Build_index_tuple<0>
> {
> typedef _Index_tuple<> __type;
> };
>
> template<std::size_t, typename, typename, std::size_t>
> struct __make_tuple_impl;
>
> template<std::size_t _Idx, typename _Tuple, typename... _Tp,
> std::size_t _Nm>
> struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
> {
> typedef typename __make_tuple_impl<_Idx + 1, tuple<_Tp...,
> typename std::tuple_element<_Idx, _Tuple>::type>, _Tuple, _Nm>::__type
> __type;
> };
>
> template<std::size_t _Nm, typename _Tuple, typename... _Tp>
> struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
> {
> typedef tuple<_Tp...> __type;
> };
>
> template<typename _Tuple>
> struct __do_make_tuple
> : public __make_tuple_impl<0, tuple<>, _Tuple,
> std::tuple_size<_Tuple>::value>
> { };
>
>
> template<typename _Tuple>
> struct __make_tuple
> : public __do_make_tuple<typename std::remove_cv
> <typename std::remove_reference<_Tuple>::type>::type>
> { };
>
>
> template<typename...>
> struct __combine_tuples;
>
> template<>
> struct __combine_tuples<>
> {
> typedef tuple<> __type;
> };
>
> template<typename... _Ts>
> struct __combine_tuples<tuple<_Ts...>>
> {
> typedef tuple<_Ts...> __type;
> };
>
> template<typename... _T1s, typename... _T2s, typename... _Rem>
> struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
> {
> typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
> _Rem...>::__type __type;
> };
>
>
> template<typename... _Tpls>
> struct __tuple_cat_result
> {
> typedef typename __combine_tuples
> <typename __make_tuple<_Tpls>::__type...>::__type __type;
> };
>
>
>
> template<typename...>
> struct __make_1st_indices;
>
> template<>
> struct __make_1st_indices<>
> {
> typedef std::_Index_tuple<> __type;
> };
>
> template<typename _Tp, typename... _Tpls>
> struct __make_1st_indices<_Tp, _Tpls...>
> {
> typedef typename std::_Build_index_tuple<std::tuple_size<
> typename std::remove_reference<_Tp>::type>::value>::__type __type;
> };
>
>
>
>
> template<typename _Ret, typename _Indices, typename... _Tpls>
> struct __tuple_concater;
>
> template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
> struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
> {
> template<typename... _Us>
> static constexpr _Ret
> _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
> {
> typedef typename __make_1st_indices<_Tpls...>::__type __idx;
> typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
> return __next::_S_do(std::forward<_Tpls>(__tps)...,
> std::forward<_Us>(__us)...,
> std::get<_Is>(std::forward<_Tp>(__tp))...);
> }
> };
>
> template<typename _Ret>
> struct __tuple_concater<_Ret, std::_Index_tuple<>>
> {
> template<typename... _Us>
> static constexpr _Ret
> _S_do(_Us&&... __us)
> {
> return _Ret(std::forward<_Us>(__us)...);
> }
> };
>
>
> template<typename... _Tpls, typename = typename
> enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
> constexpr auto
> tuple_cat(_Tpls&&... __tpls)
> -> typename __tuple_cat_result<_Tpls...>::__type
> {
> typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
> typedef typename __make_1st_indices<_Tpls...>::__type __idx;
> typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
> return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
> }
>
>
> template<typename... _Elements>
> inline tuple<_Elements&...>
> tie(_Elements&... __args) noexcept
> { return tuple<_Elements&...>(__args...); }
>
>
> template<typename... _Elements>
> inline void
> swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
>
>
>
> struct _Swallow_assign
> {
> template<class _Tp>
> const _Swallow_assign&
> operator=(const _Tp&) const
> { return *this; }
> };
>
> const _Swallow_assign ignore{};
>
>
> template<typename... _Types, typename _Alloc>
> struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
>
>
> template<class _T1, class _T2>
> template<typename... _Args1, typename... _Args2>
> inline
> pair<_T1, _T2>::
> pair(piecewise_construct_t,
> tuple<_Args1...> __first, tuple<_Args2...> __second)
> : pair(__first, __second,
> typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
> typename _Build_index_tuple<sizeof...(_Args2)>::__type())
> { }
>
> template<class _T1, class _T2>
> template<typename... _Args1, std::size_t... _Indexes1,
> typename... _Args2, std::size_t... _Indexes2>
> inline
> pair<_T1, _T2>::
> pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
> _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
> : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
> second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
> { }
>
>
>
>
>}
># 56 "/usr/include/c++/4.8.2/functional" 2 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _MemberPointer>
> class _Mem_fn;
> template<typename _Tp, typename _Class>
> _Mem_fn<_Tp _Class::*>
> mem_fn(_Tp _Class::*) noexcept;
>
>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 constexpr 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> { };
>
>
> 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; };
>
>
>
>
>
> template<typename _Functor>
> struct _Weak_result_type_impl
> : _Maybe_get_result_type<__has_result_type<_Functor>::value, _Functor>
> { };
>
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes...)>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes......)>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
> { typedef _Res result_type; };
>
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
> { typedef _Res result_type; };
>
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
> { typedef _Res result_type; };
>
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
> { typedef _Res result_type; };
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
> { typedef _Res result_type; };
>
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
> { typedef _Res result_type; };
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
> { typedef _Res result_type; };
>
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
> { typedef _Res result_type; };
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
> { typedef _Res result_type; };
>
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
> const volatile>
> { typedef _Res result_type; };
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
> const volatile>
> { typedef _Res result_type; };
>
>
>
>
>
> template<typename _Functor>
> struct _Weak_result_type
> : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
> { };
>
>
> 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>*);
>
>
>
> static __two __test(...);
>
> public:
> static const bool value = sizeof(__test((_Tp*)0)) == 1;
> };
>
>
> 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>*);
>
>
>
> static __two __test(...);
>
> public:
> static const bool value = sizeof(__test((_Tp*)0)) == 1;
> };
>
>
>
>
>
> template<typename _Functor, typename... _Args>
> inline
> typename 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(std::forward<_Args>(__args)...);
> }
>
> template<typename _Functor, typename... _Args>
> inline
> typename 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 std::mem_fn(__f)(std::forward<_Args>(__args)...);
> }
>
>
> template<typename _Functor, typename... _Args>
> inline
> typename 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(std::forward<_Args>(__args)...);
> }
>
>
>
>
>
>
> template<bool _Unary, bool _Binary, typename _Tp>
> struct _Reference_wrapper_base_impl;
>
>
> template<typename _Tp>
> struct _Reference_wrapper_base_impl<false, false, _Tp>
> : _Weak_result_type<_Tp>
> { };
>
>
> template<typename _Tp>
> struct _Reference_wrapper_base_impl<true, false, _Tp>
> : _Weak_result_type<_Tp>
> {
> typedef typename _Tp::argument_type argument_type;
> };
>
>
> template<typename _Tp>
> struct _Reference_wrapper_base_impl<false, true, _Tp>
> : _Weak_result_type<_Tp>
> {
> typedef typename _Tp::first_argument_type first_argument_type;
> typedef typename _Tp::second_argument_type second_argument_type;
> };
>
>
> template<typename _Tp>
> struct _Reference_wrapper_base_impl<true, true, _Tp>
> : _Weak_result_type<_Tp>
> {
> typedef typename _Tp::argument_type argument_type;
> typedef typename _Tp::first_argument_type first_argument_type;
> typedef typename _Tp::second_argument_type second_argument_type;
> };
>
> template<typename _Tp> class __has_argument_type_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::argument_type>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_argument_type : integral_constant<bool, __has_argument_type_helper <typename remove_cv<_Tp>::type>::value> { };
> template<typename _Tp> class __has_first_argument_type_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::first_argument_type>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_first_argument_type : integral_constant<bool, __has_first_argument_type_helper <typename remove_cv<_Tp>::type>::value> { };
> template<typename _Tp> class __has_second_argument_type_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::second_argument_type>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_second_argument_type : integral_constant<bool, __has_second_argument_type_helper <typename remove_cv<_Tp>::type>::value> { };
>
>
>
>
>
>
>
> template<typename _Tp>
> struct _Reference_wrapper_base
> : _Reference_wrapper_base_impl<
> __has_argument_type<_Tp>::value,
> __has_first_argument_type<_Tp>::value
> && __has_second_argument_type<_Tp>::value,
> _Tp>
> { };
>
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res(_T1)>
> : unary_function<_T1, _Res>
> { };
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res(_T1) const>
> : unary_function<_T1, _Res>
> { };
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res(_T1) volatile>
> : unary_function<_T1, _Res>
> { };
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res(_T1) const volatile>
> : unary_function<_T1, _Res>
> { };
>
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res(_T1, _T2)>
> : binary_function<_T1, _T2, _Res>
> { };
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res(_T1, _T2) const>
> : binary_function<_T1, _T2, _Res>
> { };
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
> : binary_function<_T1, _T2, _Res>
> { };
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
> : binary_function<_T1, _T2, _Res>
> { };
>
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res(*)(_T1)>
> : unary_function<_T1, _Res>
> { };
>
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
> : binary_function<_T1, _T2, _Res>
> { };
>
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res (_T1::*)()>
> : unary_function<_T1*, _Res>
> { };
>
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
> : binary_function<_T1*, _T2, _Res>
> { };
>
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res (_T1::*)() const>
> : unary_function<const _T1*, _Res>
> { };
>
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
> : binary_function<const _T1*, _T2, _Res>
> { };
>
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
> : unary_function<volatile _T1*, _Res>
> { };
>
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
> : binary_function<volatile _T1*, _T2, _Res>
> { };
>
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
> : unary_function<const volatile _T1*, _Res>
> { };
>
>
> 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>
> {
> _Tp* _M_data;
>
> public:
> typedef _Tp type;
>
> reference_wrapper(_Tp& __indata) noexcept
> : _M_data(std::__addressof(__indata))
> { }
>
> reference_wrapper(_Tp&&) = delete;
>
> reference_wrapper(const reference_wrapper<_Tp>& __inref) noexcept
> : _M_data(__inref._M_data)
> { }
>
> reference_wrapper&
> operator=(const reference_wrapper<_Tp>& __inref) noexcept
> {
> _M_data = __inref._M_data;
> return *this;
> }
>
> operator _Tp&() const noexcept
> { return this->get(); }
>
> _Tp&
> get() const noexcept
> { return *_M_data; }
>
> template<typename... _Args>
> typename result_of<_Tp&(_Args&&...)>::type
> operator()(_Args&&... __args) const
> {
> return __invoke(get(), std::forward<_Args>(__args)...);
> }
> };
>
>
>
> template<typename _Tp>
> inline reference_wrapper<_Tp>
> ref(_Tp& __t) noexcept
> { return reference_wrapper<_Tp>(__t); }
>
>
> template<typename _Tp>
> inline reference_wrapper<const _Tp>
> cref(const _Tp& __t) noexcept
> { return reference_wrapper<const _Tp>(__t); }
>
> template<typename _Tp>
> void ref(const _Tp&&) = delete;
>
> template<typename _Tp>
> void cref(const _Tp&&) = delete;
>
>
> template<typename _Tp>
> inline reference_wrapper<_Tp>
> ref(reference_wrapper<_Tp> __t) noexcept
> { return ref(__t.get()); }
>
>
> template<typename _Tp>
> inline reference_wrapper<const _Tp>
> cref(reference_wrapper<_Tp> __t) noexcept
> { return cref(__t.get()); }
>
>
>
> template<typename... _Types>
> struct _Pack : integral_constant<size_t, sizeof...(_Types)>
> { };
>
> template<typename _From, typename _To, bool = _From::value == _To::value>
> struct _AllConvertible : false_type
> { };
>
> template<typename... _From, typename... _To>
> struct _AllConvertible<_Pack<_From...>, _Pack<_To...>, true>
> : __and_<is_convertible<_From, _To>...>
> { };
>
> template<typename _Tp1, typename _Tp2>
> using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type,
> typename std::decay<_Tp2>::type>>;
>
>
>
>
>
>
> template<typename _Res, typename... _ArgTypes>
> struct _Maybe_unary_or_binary_function { };
>
>
> template<typename _Res, typename _T1>
> struct _Maybe_unary_or_binary_function<_Res, _T1>
> : std::unary_function<_T1, _Res> { };
>
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
> : std::binary_function<_T1, _T2, _Res> { };
>
>
> 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, typename... _Args>
> _Res
> _M_call(_Tp&& __object, const volatile _Class *,
> _Args&&... __args) const
> {
> return (std::forward<_Tp>(__object).*__pmf)
> (std::forward<_Args>(__args)...);
> }
>
> template<typename _Tp, typename... _Args>
> _Res
> _M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
> { return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
>
>
> template<typename... _Args>
> using _RequireValidArgs
> = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
>
>
>
> template<typename _Tp, typename... _Args>
> using _RequireValidArgs2
> = _Require<_NotSame<_Class, _Tp>, _NotSame<_Class*, _Tp>,
> _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
>
>
>
> template<typename _Tp, typename... _Args>
> using _RequireValidArgs3
> = _Require<is_base_of<_Class, _Tp>,
> _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
>
> public:
> typedef _Res result_type;
>
> explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
>
>
> template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
> _Res
> operator()(_Class& __object, _Args&&... __args) const
> { return (__object.*__pmf)(std::forward<_Args>(__args)...); }
>
> template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
> _Res
> operator()(_Class&& __object, _Args&&... __args) const
> {
> return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
> }
>
>
> template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
> _Res
> operator()(_Class* __object, _Args&&... __args) const
> { return (__object->*__pmf)(std::forward<_Args>(__args)...); }
>
>
> template<typename _Tp, typename... _Args,
> typename _Req = _RequireValidArgs2<_Tp, _Args...>>
> _Res
> operator()(_Tp&& __object, _Args&&... __args) const
> {
> return _M_call(std::forward<_Tp>(__object), &__object,
> std::forward<_Args>(__args)...);
> }
>
> template<typename _Tp, typename... _Args,
> typename _Req = _RequireValidArgs3<_Tp, _Args...>>
> _Res
> operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
> { return operator()(__ref.get(), std::forward<_Args>(__args)...); }
>
> private:
> _Functor __pmf;
> };
>
>
> 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, typename... _Args>
> _Res
> _M_call(_Tp&& __object, const volatile _Class *,
> _Args&&... __args) const
> {
> return (std::forward<_Tp>(__object).*__pmf)
> (std::forward<_Args>(__args)...);
> }
>
> template<typename _Tp, typename... _Args>
> _Res
> _M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
> { return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
>
> template<typename... _Args>
> using _RequireValidArgs
> = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
>
> template<typename _Tp, typename... _Args>
> using _RequireValidArgs2
> = _Require<_NotSame<_Class, _Tp>, _NotSame<const _Class*, _Tp>,
> _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
>
> template<typename _Tp, typename... _Args>
> using _RequireValidArgs3
> = _Require<is_base_of<_Class, _Tp>,
> _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
>
> public:
> typedef _Res result_type;
>
> explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
>
>
> template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
> _Res
> operator()(const _Class& __object, _Args&&... __args) const
> { return (__object.*__pmf)(std::forward<_Args>(__args)...); }
>
> template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
> _Res
> operator()(const _Class&& __object, _Args&&... __args) const
> {
> return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
> }
>
>
> template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
> _Res
> operator()(const _Class* __object, _Args&&... __args) const
> { return (__object->*__pmf)(std::forward<_Args>(__args)...); }
>
>
> template<typename _Tp, typename... _Args,
> typename _Req = _RequireValidArgs2<_Tp, _Args...>>
> _Res operator()(_Tp&& __object, _Args&&... __args) const
> {
> return _M_call(std::forward<_Tp>(__object), &__object,
> std::forward<_Args>(__args)...);
> }
>
> template<typename _Tp, typename... _Args,
> typename _Req = _RequireValidArgs3<_Tp, _Args...>>
> _Res
> operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
> { return operator()(__ref.get(), std::forward<_Args>(__args)...); }
>
> private:
> _Functor __pmf;
> };
>
>
> 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, typename... _Args>
> _Res
> _M_call(_Tp&& __object, const volatile _Class *,
> _Args&&... __args) const
> {
> return (std::forward<_Tp>(__object).*__pmf)
> (std::forward<_Args>(__args)...);
> }
>
> template<typename _Tp, typename... _Args>
> _Res
> _M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
> { return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
>
> template<typename... _Args>
> using _RequireValidArgs
> = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
>
> template<typename _Tp, typename... _Args>
> using _RequireValidArgs2
> = _Require<_NotSame<_Class, _Tp>, _NotSame<volatile _Class*, _Tp>,
> _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
>
> template<typename _Tp, typename... _Args>
> using _RequireValidArgs3
> = _Require<is_base_of<_Class, _Tp>,
> _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
>
> public:
> typedef _Res result_type;
>
> explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
>
>
> template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
> _Res
> operator()(volatile _Class& __object, _Args&&... __args) const
> { return (__object.*__pmf)(std::forward<_Args>(__args)...); }
>
> template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
> _Res
> operator()(volatile _Class&& __object, _Args&&... __args) const
> {
> return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
> }
>
>
> template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
> _Res
> operator()(volatile _Class* __object, _Args&&... __args) const
> { return (__object->*__pmf)(std::forward<_Args>(__args)...); }
>
>
> template<typename _Tp, typename... _Args,
> typename _Req = _RequireValidArgs2<_Tp, _Args...>>
> _Res
> operator()(_Tp&& __object, _Args&&... __args) const
> {
> return _M_call(std::forward<_Tp>(__object), &__object,
> std::forward<_Args>(__args)...);
> }
>
> template<typename _Tp, typename... _Args,
> typename _Req = _RequireValidArgs3<_Tp, _Args...>>
> _Res
> operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
> { return operator()(__ref.get(), std::forward<_Args>(__args)...); }
>
> private:
> _Functor __pmf;
> };
>
>
> 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, typename... _Args>
> _Res
> _M_call(_Tp&& __object, const volatile _Class *,
> _Args&&... __args) const
> {
> return (std::forward<_Tp>(__object).*__pmf)
> (std::forward<_Args>(__args)...);
> }
>
> template<typename _Tp, typename... _Args>
> _Res
> _M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
> { return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
>
> template<typename... _Args>
> using _RequireValidArgs
> = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
>
> template<typename _Tp, typename... _Args>
> using _RequireValidArgs2
> = _Require<_NotSame<_Class, _Tp>,
> _NotSame<const volatile _Class*, _Tp>,
> _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
>
> template<typename _Tp, typename... _Args>
> using _RequireValidArgs3
> = _Require<is_base_of<_Class, _Tp>,
> _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
>
> public:
> typedef _Res result_type;
>
> explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
>
>
> template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
> _Res
> operator()(const volatile _Class& __object, _Args&&... __args) const
> { return (__object.*__pmf)(std::forward<_Args>(__args)...); }
>
> template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
> _Res
> operator()(const volatile _Class&& __object, _Args&&... __args) const
> {
> return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
> }
>
>
> template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
> _Res
> operator()(const volatile _Class* __object, _Args&&... __args) const
> { return (__object->*__pmf)(std::forward<_Args>(__args)...); }
>
>
> template<typename _Tp, typename... _Args,
> typename _Req = _RequireValidArgs2<_Tp, _Args...>>
> _Res operator()(_Tp&& __object, _Args&&... __args) const
> {
> return _M_call(std::forward<_Tp>(__object), &__object,
> std::forward<_Args>(__args)...);
> }
>
> template<typename _Tp, typename... _Args,
> typename _Req = _RequireValidArgs3<_Tp, _Args...>>
> _Res
> operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
> { return operator()(__ref.get(), std::forward<_Args>(__args)...); }
>
> private:
> _Functor __pmf;
> };
>
>
> 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;
> };
>
> template<typename _Res, typename _Class>
> class _Mem_fn<_Res _Class::*>
> {
> using __pm_type = _Res _Class::*;
>
>
>
>
> template<typename _Tp>
> auto
> _M_call(_Tp&& __object, const _Class *) const noexcept
> -> decltype(std::forward<_Tp>(__object).*std::declval<__pm_type&>())
> { return std::forward<_Tp>(__object).*__pm; }
>
> template<typename _Tp, typename _Up>
> auto
> _M_call(_Tp&& __object, _Up * const *) const noexcept
> -> decltype((*std::forward<_Tp>(__object)).*std::declval<__pm_type&>())
> { return (*std::forward<_Tp>(__object)).*__pm; }
>
> template<typename _Tp>
> auto
> _M_call(_Tp&& __ptr, const volatile void*) const
> noexcept(noexcept((*__ptr).*std::declval<__pm_type&>()))
> -> decltype((*__ptr).*std::declval<__pm_type&>())
> { return (*__ptr).*__pm; }
>
> public:
> explicit
> _Mem_fn(_Res _Class::*__pm) noexcept : __pm(__pm) { }
>
>
> _Res&
> operator()(_Class& __object) const noexcept
> { return __object.*__pm; }
>
> const _Res&
> operator()(const _Class& __object) const noexcept
> { return __object.*__pm; }
>
> _Res&&
> operator()(_Class&& __object) const noexcept
> { return std::forward<_Class>(__object).*__pm; }
>
> const _Res&&
> operator()(const _Class&& __object) const noexcept
> { return std::forward<const _Class>(__object).*__pm; }
>
>
> _Res&
> operator()(_Class* __object) const noexcept
> { return __object->*__pm; }
>
> const _Res&
> operator()(const _Class* __object) const noexcept
> { return __object->*__pm; }
>
>
> template<typename _Tp, typename _Req = _Require<_NotSame<_Class*, _Tp>>>
> auto
> operator()(_Tp&& __unknown) const
> noexcept(noexcept(std::declval<_Mem_fn*>()->_M_call
> (std::forward<_Tp>(__unknown), &__unknown)))
> -> decltype(this->_M_call(std::forward<_Tp>(__unknown), &__unknown))
> { return _M_call(std::forward<_Tp>(__unknown), &__unknown); }
>
> template<typename _Tp, typename _Req = _Require<is_base_of<_Class, _Tp>>>
> auto
> operator()(reference_wrapper<_Tp> __ref) const
> noexcept(noexcept(std::declval<_Mem_fn&>()(__ref.get())))
> -> decltype((*this)(__ref.get()))
> { return (*this)(__ref.get()); }
>
> private:
> _Res _Class::*__pm;
> };
># 959 "/usr/include/c++/4.8.2/functional" 3
> template<typename _Tp, typename _Class>
> inline _Mem_fn<_Tp _Class::*>
> mem_fn(_Tp _Class::* __pm) noexcept
> {
> return _Mem_fn<_Tp _Class::*>(__pm);
> }
>
>
>
>
>
>
>
> template<typename _Tp>
> struct is_bind_expression
> : public false_type { };
>
>
>
>
>
>
> template<typename _Tp>
> struct is_placeholder
> : public integral_constant<int, 0>
> { };
>
>
>
>
> template<int _Num> struct _Placeholder { };
>
> 
>
>
>
>
>
> namespace placeholders
> {
> 
>
>
>
>
> extern const _Placeholder<1> _1;
> extern const _Placeholder<2> _2;
> extern const _Placeholder<3> _3;
> extern const _Placeholder<4> _4;
> extern const _Placeholder<5> _5;
> extern const _Placeholder<6> _6;
> extern const _Placeholder<7> _7;
> extern const _Placeholder<8> _8;
> extern const _Placeholder<9> _9;
> extern const _Placeholder<10> _10;
> extern const _Placeholder<11> _11;
> extern const _Placeholder<12> _12;
> extern const _Placeholder<13> _13;
> extern const _Placeholder<14> _14;
> extern const _Placeholder<15> _15;
> extern const _Placeholder<16> _16;
> extern const _Placeholder<17> _17;
> extern const _Placeholder<18> _18;
> extern const _Placeholder<19> _19;
> extern const _Placeholder<20> _20;
> extern const _Placeholder<21> _21;
> extern const _Placeholder<22> _22;
> extern const _Placeholder<23> _23;
> extern const _Placeholder<24> _24;
> extern const _Placeholder<25> _25;
> extern const _Placeholder<26> _26;
> extern const _Placeholder<27> _27;
> extern const _Placeholder<28> _28;
> extern const _Placeholder<29> _29;
> 
> }
>
> 
>
>
>
>
>
>
> template<int _Num>
> struct is_placeholder<_Placeholder<_Num> >
> : public integral_constant<int, _Num>
> { };
>
> template<int _Num>
> struct is_placeholder<const _Placeholder<_Num> >
> : public integral_constant<int, _Num>
> { };
>
>
>
>
>
> struct _No_tuple_element;
>
>
>
>
>
>
> template<std::size_t __i, typename _Tuple, bool _IsSafe>
> struct _Safe_tuple_element_impl
> : tuple_element<__i, _Tuple> { };
>
>
>
>
>
>
> template<std::size_t __i, typename _Tuple>
> struct _Safe_tuple_element_impl<__i, _Tuple, false>
> {
> typedef _No_tuple_element type;
> };
>
>
>
>
>
> template<std::size_t __i, typename _Tuple>
> struct _Safe_tuple_element
> : _Safe_tuple_element_impl<__i, _Tuple,
> (__i < tuple_size<_Tuple>::value)>
> { };
># 1100 "/usr/include/c++/4.8.2/functional" 3
> template<typename _Arg,
> bool _IsBindExp = is_bind_expression<_Arg>::value,
> bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
> class _Mu;
>
>
>
>
>
> template<typename _Tp>
> class _Mu<reference_wrapper<_Tp>, false, false>
> {
> public:
> typedef _Tp& result_type;
>
>
>
>
>
> template<typename _CVRef, typename _Tuple>
> result_type
> operator()(_CVRef& __arg, _Tuple&) const volatile
> { return __arg.get(); }
> };
>
>
>
>
>
>
> template<typename _Arg>
> class _Mu<_Arg, true, false>
> {
> public:
> template<typename _CVArg, typename... _Args>
> auto
> operator()(_CVArg& __arg,
> tuple<_Args...>& __tuple) const volatile
> -> decltype(__arg(declval<_Args>()...))
> {
>
> typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
> _Indexes;
> return this->__call(__arg, __tuple, _Indexes());
> }
>
> private:
>
>
> template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
> auto
> __call(_CVArg& __arg, tuple<_Args...>& __tuple,
> const _Index_tuple<_Indexes...>&) const volatile
> -> decltype(__arg(declval<_Args>()...))
> {
> return __arg(std::forward<_Args>(get<_Indexes>(__tuple))...);
> }
> };
>
>
>
>
>
>
> 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)>
> {
>
>
>
> typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value
> - 1), _Tuple>::type
> __base_type;
>
> public:
> typedef typename add_rvalue_reference<__base_type>::type type;
> };
>
> template<typename _Tuple>
> typename result<_Mu(_Arg, _Tuple)>::type
> operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
> {
> return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>(
> ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
> }
> };
>
>
>
>
>
>
> 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_lvalue_reference<_CVArg>::type type;
> };
>
>
> template<typename _CVArg, typename _Tuple>
> _CVArg&&
> operator()(_CVArg&& __arg, _Tuple&) const volatile
> { return std::forward<_CVArg>(__arg); }
> };
>
>
>
>
>
>
> template<typename _Tp>
> struct _Maybe_wrap_member_pointer
> {
> typedef _Tp type;
>
> static const _Tp&
> __do_wrap(const _Tp& __x)
> { return __x; }
>
> static _Tp&&
> __do_wrap(_Tp&& __x)
> { return static_cast<_Tp&&>(__x); }
> };
>
>
>
>
>
>
> 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); }
> };
>
>
>
>
>
> template<>
> struct _Maybe_wrap_member_pointer<void>
> {
> typedef void type;
> };
>
>
> template<std::size_t _Ind, typename... _Tp>
> inline auto
> __volget(volatile tuple<_Tp...>& __tuple)
> -> typename tuple_element<_Ind, tuple<_Tp...>>::type volatile&
> { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }
>
>
> template<std::size_t _Ind, typename... _Tp>
> inline auto
> __volget(const volatile tuple<_Tp...>& __tuple)
> -> typename tuple_element<_Ind, tuple<_Tp...>>::type const volatile&
> { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
>
>
> 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;
>
>
> template<typename _Result, typename... _Args, std::size_t... _Indexes>
> _Result
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
> {
> return _M_f(_Mu<_Bound_args>()
> (get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Result, typename... _Args, std::size_t... _Indexes>
> _Result
> __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
> {
> return _M_f(_Mu<_Bound_args>()
> (get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Result, typename... _Args, std::size_t... _Indexes>
> _Result
> __call_v(tuple<_Args...>&& __args,
> _Index_tuple<_Indexes...>) volatile
> {
> return _M_f(_Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Result, typename... _Args, std::size_t... _Indexes>
> _Result
> __call_c_v(tuple<_Args...>&& __args,
> _Index_tuple<_Indexes...>) const volatile
> {
> return _M_f(_Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
> public:
> template<typename... _Args>
> explicit _Bind(const _Functor& __f, _Args&&... __args)
> : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
> { }
>
> template<typename... _Args>
> explicit _Bind(_Functor&& __f, _Args&&... __args)
> : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
> { }
>
> _Bind(const _Bind&) = default;
>
> _Bind(_Bind&& __b)
> : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
> { }
>
>
> template<typename... _Args, typename _Result
> = decltype( std::declval<_Functor>()(
> _Mu<_Bound_args>()( std::declval<_Bound_args&>(),
> std::declval<tuple<_Args...>&>() )... ) )>
> _Result
> operator()(_Args&&... __args)
> {
> return this->__call<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args, typename _Result
> = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
> typename add_const<_Functor>::type>::type>()(
> _Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
> std::declval<tuple<_Args...>&>() )... ) )>
> _Result
> operator()(_Args&&... __args) const
> {
> return this->__call_c<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args, typename _Result
> = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
> typename add_volatile<_Functor>::type>::type>()(
> _Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
> std::declval<tuple<_Args...>&>() )... ) )>
> _Result
> operator()(_Args&&... __args) volatile
> {
> return this->__call_v<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args, typename _Result
> = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
> typename add_cv<_Functor>::type>::type>()(
> _Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
> std::declval<tuple<_Args...>&>() )... ) )>
> _Result
> operator()(_Args&&... __args) const volatile
> {
> return this->__call_c_v<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
> };
>
>
> 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;
>
>
> template<typename _Res>
> struct __enable_if_void : enable_if<is_void<_Res>::value, int> { };
> template<typename _Res>
> struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { };
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> _Result
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
> typename __disable_if_void<_Res>::type = 0)
> {
> return _M_f(_Mu<_Bound_args>()
> (get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> void
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
> typename __enable_if_void<_Res>::type = 0)
> {
> _M_f(_Mu<_Bound_args>()
> (get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> _Result
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
> typename __disable_if_void<_Res>::type = 0) const
> {
> return _M_f(_Mu<_Bound_args>()
> (get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> void
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
> typename __enable_if_void<_Res>::type = 0) const
> {
> _M_f(_Mu<_Bound_args>()
> (get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> _Result
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
> typename __disable_if_void<_Res>::type = 0) volatile
> {
> return _M_f(_Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> void
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
> typename __enable_if_void<_Res>::type = 0) volatile
> {
> _M_f(_Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> _Result
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
> typename __disable_if_void<_Res>::type = 0) const volatile
> {
> return _M_f(_Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> void
> __call(tuple<_Args...>&& __args,
> _Index_tuple<_Indexes...>,
> typename __enable_if_void<_Res>::type = 0) const volatile
> {
> _M_f(_Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
> public:
> typedef _Result result_type;
>
> template<typename... _Args>
> explicit _Bind_result(const _Functor& __f, _Args&&... __args)
> : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
> { }
>
> template<typename... _Args>
> explicit _Bind_result(_Functor&& __f, _Args&&... __args)
> : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
> { }
>
> _Bind_result(const _Bind_result&) = default;
>
> _Bind_result(_Bind_result&& __b)
> : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
> { }
>
>
> template<typename... _Args>
> result_type
> operator()(_Args&&... __args)
> {
> return this->__call<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args>
> result_type
> operator()(_Args&&... __args) const
> {
> return this->__call<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args>
> result_type
> operator()(_Args&&... __args) volatile
> {
> return this->__call<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args>
> result_type
> operator()(_Args&&... __args) const volatile
> {
> return this->__call<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
> };
>
>
>
>
>
> template<typename _Signature>
> struct is_bind_expression<_Bind<_Signature> >
> : public true_type { };
>
>
>
>
>
> template<typename _Signature>
> struct is_bind_expression<const _Bind<_Signature> >
> : public true_type { };
>
>
>
>
>
> template<typename _Signature>
> struct is_bind_expression<volatile _Bind<_Signature> >
> : public true_type { };
>
>
>
>
>
> template<typename _Signature>
> struct is_bind_expression<const volatile _Bind<_Signature>>
> : public true_type { };
>
>
>
>
>
> template<typename _Result, typename _Signature>
> struct is_bind_expression<_Bind_result<_Result, _Signature>>
> : public true_type { };
>
>
>
>
>
> template<typename _Result, typename _Signature>
> struct is_bind_expression<const _Bind_result<_Result, _Signature>>
> : public true_type { };
>
>
>
>
>
> template<typename _Result, typename _Signature>
> struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
> : public true_type { };
>
>
>
>
>
> template<typename _Result, typename _Signature>
> struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
> : public true_type { };
>
>
>
>
> template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
> using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;
>
> template<bool _SocketLike, typename _Func, typename... _BoundArgs>
> struct _Bind_helper
> {
> typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
> __maybe_type;
> typedef typename __maybe_type::type __func_type;
> typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
> };
>
>
>
>
> template<typename _Func, typename... _BoundArgs>
> struct _Bind_helper<true, _Func, _BoundArgs...>
> { };
>
>
>
>
>
> template<typename _Func, typename... _BoundArgs>
> inline typename
> _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
> bind(_Func&& __f, _BoundArgs&&... __args)
> {
> typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
> typedef typename __helper_type::__maybe_type __maybe_type;
> typedef typename __helper_type::type __result_type;
> return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
> std::forward<_BoundArgs>(__args)...);
> }
>
> template<typename _Result, typename _Func, typename... _BoundArgs>
> struct _Bindres_helper
> {
> typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
> __maybe_type;
> typedef typename __maybe_type::type __functor_type;
> typedef _Bind_result<_Result,
> __functor_type(typename decay<_BoundArgs>::type...)>
> type;
> };
>
>
>
>
>
> template<typename _Result, typename _Func, typename... _BoundArgs>
> inline
> typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
> bind(_Func&& __f, _BoundArgs&&... __args)
> {
> typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
> typedef typename __helper_type::__maybe_type __maybe_type;
> typedef typename __helper_type::type __result_type;
> return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
> std::forward<_BoundArgs>(__args)...);
> }
>
> template<typename _Signature>
> struct _Bind_simple;
>
> template<typename _Callable, typename... _Args>
> struct _Bind_simple<_Callable(_Args...)>
> {
> typedef typename result_of<_Callable(_Args...)>::type result_type;
>
> template<typename... _Args2, typename = typename
> enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
> explicit
> _Bind_simple(const _Callable& __callable, _Args2&&... __args)
> : _M_bound(__callable, std::forward<_Args2>(__args)...)
> { }
>
> template<typename... _Args2, typename = typename
> enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
> explicit
> _Bind_simple(_Callable&& __callable, _Args2&&... __args)
> : _M_bound(std::move(__callable), std::forward<_Args2>(__args)...)
> { }
>
> _Bind_simple(const _Bind_simple&) = default;
> _Bind_simple(_Bind_simple&&) = default;
>
> result_type
> operator()()
> {
> typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indices;
> return _M_invoke(_Indices());
> }
>
> private:
>
> template<std::size_t... _Indices>
> typename result_of<_Callable(_Args...)>::type
> _M_invoke(_Index_tuple<_Indices...>)
> {
>
>
> return std::forward<_Callable>(std::get<0>(_M_bound))(
> std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
> }
>
> std::tuple<_Callable, _Args...> _M_bound;
> };
>
> template<typename _Func, typename... _BoundArgs>
> struct _Bind_simple_helper
> {
> typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
> __maybe_type;
> typedef typename __maybe_type::type __func_type;
> typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)>
> __type;
> };
>
>
>
> template<typename _Callable, typename... _Args>
> typename _Bind_simple_helper<_Callable, _Args...>::__type
> __bind_simple(_Callable&& __callable, _Args&&... __args)
> {
> typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
> typedef typename __helper_type::__maybe_type __maybe_type;
> typedef typename __helper_type::__type __result_type;
> return __result_type(
> __maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
> std::forward<_Args>(__args)...);
> }
>
>
>
>
>
>
> class bad_function_call : public std::exception
> {
> public:
> virtual ~bad_function_call() noexcept;
>
> const char* what() const noexcept;
> };
>
>
>
>
>
>
> 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
> };
>
>
>
> 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>
> { };
>
>
>
> 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 std::mem_fn(__p); }
>
> template<typename _Member, typename _Class>
> inline _Mem_fn<_Member _Class::*>
> __callable_functor(_Member _Class::* const &__p)
> { return std::mem_fn(__p); }
>
> template<typename _Member, typename _Class>
> inline _Mem_fn<_Member _Class::*>
> __callable_functor(_Member _Class::* volatile &__p)
> { return std::mem_fn(__p); }
>
> template<typename _Member, typename _Class>
> inline _Mem_fn<_Member _Class::*>
> __callable_functor(_Member _Class::* const volatile &__p)
> { return std::mem_fn(__p); }
>
> template<typename _Signature>
> class function;
>
>
> 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;
>
>
> static _Functor*
> _M_get_pointer(const _Any_data& __source)
> {
> const _Functor* __ptr =
> __stored_locally? std::__addressof(__source._M_access<_Functor>())
> : __source._M_access<_Functor*>();
> return const_cast<_Functor*>(__ptr);
> }
>
>
>
> static void
> _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
> {
> new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
> }
>
>
>
> static void
> _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
> {
> __dest._M_access<_Functor*>() =
> new _Functor(*__source._M_access<_Functor*>());
> }
>
>
>
> static void
> _M_destroy(_Any_data& __victim, true_type)
> {
> __victim._M_access<_Functor>().~_Functor();
> }
>
>
> 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, _Functor&& __f)
> { _M_init_functor(__functor, std::move(__f), _Local_storage()); }
>
> template<typename _Signature>
> static bool
> _M_not_empty_function(const function<_Signature>& __f)
> { return static_cast<bool>(__f); }
>
> template<typename _Tp>
> static bool
> _M_not_empty_function(_Tp* const& __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, _Functor&& __f, true_type)
> { new (__functor._M_access()) _Functor(std::move(__f)); }
>
> static void
> _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
> { __functor._M_access<_Functor*>() = new _Functor(std::move(__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)
> {
> _Base::_M_init_functor(__functor, std::__addressof(__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))(
> std::forward<_ArgTypes>(__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))(
> std::forward<_ArgTypes>(__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))(
> std::forward<_ArgTypes>(__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))(
> std::forward<_ArgTypes>(__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 std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
> std::forward<_ArgTypes>(__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)
> {
> std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
> std::forward<_ArgTypes>(__args)...);
> }
> };
>
> template<typename _From, typename _To>
> using __check_func_return_type
> = __or_<is_void<_To>, is_convertible<_From, _To>>;
>
>
>
>
>
>
>
> template<typename _Res, typename... _ArgTypes>
> class function<_Res(_ArgTypes...)>
> : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
> private _Function_base
> {
> typedef _Res _Signature_type(_ArgTypes...);
>
> template<typename _Functor>
> using _Invoke = decltype(__callable_functor(std::declval<_Functor&>())
> (std::declval<_ArgTypes>()...) );
>
> template<typename _Functor>
> using _Callable = __check_func_return_type<_Invoke<_Functor>, _Res>;
>
> template<typename _Cond, typename _Tp>
> using _Requires = typename enable_if<_Cond::value, _Tp>::type;
>
> public:
> typedef _Res result_type;
>
>
>
>
>
>
>
> function() noexcept
> : _Function_base() { }
>
>
>
>
>
> function(nullptr_t) noexcept
> : _Function_base() { }
># 2217 "/usr/include/c++/4.8.2/functional" 3
> function(const function& __x);
># 2226 "/usr/include/c++/4.8.2/functional" 3
> function(function&& __x) : _Function_base()
> {
> __x.swap(*this);
> }
># 2249 "/usr/include/c++/4.8.2/functional" 3
> template<typename _Functor,
> typename = _Requires<_Callable<_Functor>, void>>
> function(_Functor);
># 2265 "/usr/include/c++/4.8.2/functional" 3
> function&
> operator=(const function& __x)
> {
> function(__x).swap(*this);
> return *this;
> }
># 2283 "/usr/include/c++/4.8.2/functional" 3
> function&
> operator=(function&& __x)
> {
> function(std::move(__x)).swap(*this);
> return *this;
> }
># 2297 "/usr/include/c++/4.8.2/functional" 3
> function&
> operator=(nullptr_t)
> {
> if (_M_manager)
> {
> _M_manager(_M_functor, _M_functor, __destroy_functor);
> _M_manager = 0;
> _M_invoker = 0;
> }
> return *this;
> }
># 2325 "/usr/include/c++/4.8.2/functional" 3
> template<typename _Functor>
> _Requires<_Callable<_Functor>, function&>
> operator=(_Functor&& __f)
> {
> function(std::forward<_Functor>(__f)).swap(*this);
> return *this;
> }
>
>
> template<typename _Functor>
> function&
> operator=(reference_wrapper<_Functor> __f) noexcept
> {
> function(__f).swap(*this);
> return *this;
> }
># 2351 "/usr/include/c++/4.8.2/functional" 3
> void swap(function& __x)
> {
> std::swap(_M_functor, __x._M_functor);
> std::swap(_M_manager, __x._M_manager);
> std::swap(_M_invoker, __x._M_invoker);
> }
># 2379 "/usr/include/c++/4.8.2/functional" 3
> explicit operator bool() const noexcept
> { return !_M_empty(); }
># 2392 "/usr/include/c++/4.8.2/functional" 3
> _Res operator()(_ArgTypes... __args) const;
># 2405 "/usr/include/c++/4.8.2/functional" 3
> const type_info& target_type() const noexcept;
># 2416 "/usr/include/c++/4.8.2/functional" 3
> template<typename _Functor> _Functor* target() noexcept;
>
>
> template<typename _Functor> const _Functor* target() const noexcept;
>
>
> private:
> 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 (static_cast<bool>(__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, typename>
> function<_Res(_ArgTypes...)>::
> function(_Functor __f)
> : _Function_base()
> {
> typedef _Function_handler<_Signature_type, _Functor> _My_handler;
>
> if (_My_handler::_M_not_empty_function(__f))
> {
> _My_handler::_M_init_functor(_M_functor, std::move(__f));
> _M_invoker = &_My_handler::_M_invoke;
> _M_manager = &_My_handler::_M_manager;
> }
> }
>
> template<typename _Res, typename... _ArgTypes>
> _Res
> function<_Res(_ArgTypes...)>::
> operator()(_ArgTypes... __args) const
> {
> if (_M_empty())
> __throw_bad_function_call();
> return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
> }
>
>
> template<typename _Res, typename... _ArgTypes>
> const type_info&
> function<_Res(_ArgTypes...)>::
> target_type() const noexcept
> {
> 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() noexcept
> {
> 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 noexcept
> {
> 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;
> }
># 2528 "/usr/include/c++/4.8.2/functional" 3
> template<typename _Res, typename... _Args>
> inline bool
> operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
> { return !static_cast<bool>(__f); }
>
>
> template<typename _Res, typename... _Args>
> inline bool
> operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
> { return !static_cast<bool>(__f); }
># 2546 "/usr/include/c++/4.8.2/functional" 3
> template<typename _Res, typename... _Args>
> inline bool
> operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
> { return static_cast<bool>(__f); }
>
>
> template<typename _Res, typename... _Args>
> inline bool
> operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
> { return static_cast<bool>(__f); }
># 2564 "/usr/include/c++/4.8.2/functional" 3
> template<typename _Res, typename... _Args>
> inline void
> swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y)
> { __x.swap(__y); }
>
>
>}
># 80 "/usr/include/c++/4.8.2/memory" 2 3
>
># 1 "/usr/include/c++/4.8.2/bits/unique_ptr.h" 1 3
># 39 "/usr/include/c++/4.8.2/bits/unique_ptr.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>
> template<typename> class auto_ptr;
>
>
>
> template<typename _Tp>
> struct default_delete
> {
> constexpr default_delete() noexcept = default;
>
> template<typename _Up, typename = typename
> enable_if<is_convertible<_Up*, _Tp*>::value>::type>
> default_delete(const default_delete<_Up>&) noexcept { }
>
> void
> operator()(_Tp* __ptr) const
> {
> static_assert(sizeof(_Tp)>0,
> "can't delete pointer to incomplete type");
> delete __ptr;
> }
> };
>
>
>
>
> template<typename _Tp>
> struct default_delete<_Tp[]>
> {
> private:
> template<typename _Up>
> using __remove_cv = typename remove_cv<_Up>::type;
>
>
> template<typename _Up>
> using __is_derived_Tp
> = __and_< is_base_of<_Tp, _Up>,
> __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
>
> public:
> constexpr default_delete() noexcept = default;
>
> template<typename _Up, typename = typename
> enable_if<!__is_derived_Tp<_Up>::value>::type>
> default_delete(const default_delete<_Up[]>&) noexcept { }
>
> void
> operator()(_Tp* __ptr) const
> {
> static_assert(sizeof(_Tp)>0,
> "can't delete pointer to incomplete type");
> delete [] __ptr;
> }
>
> template<typename _Up>
> typename enable_if<__is_derived_Tp<_Up>::value>::type
> operator()(_Up*) const = delete;
> };
>
>
> template <typename _Tp, typename _Dp = default_delete<_Tp> >
> class unique_ptr
> {
>
> class _Pointer
> {
> template<typename _Up>
> static typename _Up::pointer __test(typename _Up::pointer*);
>
> template<typename _Up>
> static _Tp* __test(...);
>
> typedef typename remove_reference<_Dp>::type _Del;
>
> public:
> typedef decltype(__test<_Del>(0)) type;
> };
>
> typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
> __tuple_type _M_t;
>
> public:
> typedef typename _Pointer::type pointer;
> typedef _Tp element_type;
> typedef _Dp deleter_type;
>
>
> constexpr unique_ptr() noexcept
> : _M_t()
> { static_assert(!is_pointer<deleter_type>::value,
> "constructed with null function pointer deleter"); }
>
> explicit
> unique_ptr(pointer __p) noexcept
> : _M_t(__p, deleter_type())
> { static_assert(!is_pointer<deleter_type>::value,
> "constructed with null function pointer deleter"); }
>
> unique_ptr(pointer __p,
> typename conditional<is_reference<deleter_type>::value,
> deleter_type, const deleter_type&>::type __d) noexcept
> : _M_t(__p, __d) { }
>
> unique_ptr(pointer __p,
> typename remove_reference<deleter_type>::type&& __d) noexcept
> : _M_t(std::move(__p), std::move(__d))
> { static_assert(!std::is_reference<deleter_type>::value,
> "rvalue deleter bound to reference"); }
>
> constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
>
>
> unique_ptr(unique_ptr&& __u) noexcept
> : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
>
> template<typename _Up, typename _Ep, typename = _Require<
> is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
> __not_<is_array<_Up>>,
> typename conditional<is_reference<_Dp>::value,
> is_same<_Ep, _Dp>,
> is_convertible<_Ep, _Dp>>::type>>
> unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
> : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
> { }
>
>
> template<typename _Up, typename = _Require<
> is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
> unique_ptr(auto_ptr<_Up>&& __u) noexcept;
>
>
>
> ~unique_ptr() noexcept
> {
> auto& __ptr = std::get<0>(_M_t);
> if (__ptr != nullptr)
> get_deleter()(__ptr);
> __ptr = pointer();
> }
>
>
> unique_ptr&
> operator=(unique_ptr&& __u) noexcept
> {
> reset(__u.release());
> get_deleter() = std::forward<deleter_type>(__u.get_deleter());
> return *this;
> }
>
> template<typename _Up, typename _Ep>
> typename enable_if< __and_<
> is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
> __not_<is_array<_Up>>
> >::value,
> unique_ptr&>::type
> operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
> {
> reset(__u.release());
> get_deleter() = std::forward<_Ep>(__u.get_deleter());
> return *this;
> }
>
> unique_ptr&
> operator=(nullptr_t) noexcept
> {
> reset();
> return *this;
> }
>
>
> typename add_lvalue_reference<element_type>::type
> operator*() const
> {
> ;
> return *get();
> }
>
> pointer
> operator->() const noexcept
> {
> ;
> return get();
> }
>
> pointer
> get() const noexcept
> { return std::get<0>(_M_t); }
>
> deleter_type&
> get_deleter() noexcept
> { return std::get<1>(_M_t); }
>
> const deleter_type&
> get_deleter() const noexcept
> { return std::get<1>(_M_t); }
>
> explicit operator bool() const noexcept
> { return get() == pointer() ? false : true; }
>
>
> pointer
> release() noexcept
> {
> pointer __p = get();
> std::get<0>(_M_t) = pointer();
> return __p;
> }
>
> void
> reset(pointer __p = pointer()) noexcept
> {
> using std::swap;
> swap(std::get<0>(_M_t), __p);
> if (__p != pointer())
> get_deleter()(__p);
> }
>
> void
> swap(unique_ptr& __u) noexcept
> {
> using std::swap;
> swap(_M_t, __u._M_t);
> }
>
>
> unique_ptr(const unique_ptr&) = delete;
> unique_ptr& operator=(const unique_ptr&) = delete;
> };
>
>
>
>
>
> template<typename _Tp, typename _Dp>
> class unique_ptr<_Tp[], _Dp>
> {
>
> class _Pointer
> {
> template<typename _Up>
> static typename _Up::pointer __test(typename _Up::pointer*);
>
> template<typename _Up>
> static _Tp* __test(...);
>
> typedef typename remove_reference<_Dp>::type _Del;
>
> public:
> typedef decltype(__test<_Del>(0)) type;
> };
>
> typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
> __tuple_type _M_t;
>
> template<typename _Up>
> using __remove_cv = typename remove_cv<_Up>::type;
>
>
> template<typename _Up>
> using __is_derived_Tp
> = __and_< is_base_of<_Tp, _Up>,
> __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
>
> template<typename _Up, typename _Ep,
> typename _Tp_pointer = typename _Pointer::type,
> typename _Up_pointer = typename unique_ptr<_Up, _Ep>::pointer>
> using __safe_conversion = __and_<
> is_convertible<_Up_pointer, _Tp_pointer>,
> is_array<_Up>,
> __or_<__not_<is_pointer<_Up_pointer>>,
> __not_<is_pointer<_Tp_pointer>>,
> __not_<__is_derived_Tp<typename remove_extent<_Up>::type>>
> >
> >;
>
> public:
> typedef typename _Pointer::type pointer;
> typedef _Tp element_type;
> typedef _Dp deleter_type;
>
>
> constexpr unique_ptr() noexcept
> : _M_t()
> { static_assert(!std::is_pointer<deleter_type>::value,
> "constructed with null function pointer deleter"); }
>
> explicit
> unique_ptr(pointer __p) noexcept
> : _M_t(__p, deleter_type())
> { static_assert(!is_pointer<deleter_type>::value,
> "constructed with null function pointer deleter"); }
>
> template<typename _Up, typename = _Require<is_pointer<pointer>,
> is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
> explicit
> unique_ptr(_Up* __p) = delete;
>
> unique_ptr(pointer __p,
> typename conditional<is_reference<deleter_type>::value,
> deleter_type, const deleter_type&>::type __d) noexcept
> : _M_t(__p, __d) { }
>
> unique_ptr(pointer __p, typename
> remove_reference<deleter_type>::type&& __d) noexcept
> : _M_t(std::move(__p), std::move(__d))
> { static_assert(!is_reference<deleter_type>::value,
> "rvalue deleter bound to reference"); }
>
>
> unique_ptr(unique_ptr&& __u) noexcept
> : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
>
> constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
>
> template<typename _Up, typename _Ep,
> typename = _Require<__safe_conversion<_Up, _Ep>,
> typename conditional<is_reference<_Dp>::value,
> is_same<_Ep, _Dp>,
> is_convertible<_Ep, _Dp>>::type
> >>
> unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
> : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
> { }
>
>
> ~unique_ptr()
> {
> auto& __ptr = std::get<0>(_M_t);
> if (__ptr != nullptr)
> get_deleter()(__ptr);
> __ptr = pointer();
> }
>
>
> unique_ptr&
> operator=(unique_ptr&& __u) noexcept
> {
> reset(__u.release());
> get_deleter() = std::forward<deleter_type>(__u.get_deleter());
> return *this;
> }
>
> template<typename _Up, typename _Ep>
> typename
> enable_if<__safe_conversion<_Up, _Ep>::value, unique_ptr&>::type
> operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
> {
> reset(__u.release());
> get_deleter() = std::forward<_Ep>(__u.get_deleter());
> return *this;
> }
>
> unique_ptr&
> operator=(nullptr_t) noexcept
> {
> reset();
> return *this;
> }
>
>
> typename std::add_lvalue_reference<element_type>::type
> operator[](size_t __i) const
> {
> ;
> return get()[__i];
> }
>
> pointer
> get() const noexcept
> { return std::get<0>(_M_t); }
>
> deleter_type&
> get_deleter() noexcept
> { return std::get<1>(_M_t); }
>
> const deleter_type&
> get_deleter() const noexcept
> { return std::get<1>(_M_t); }
>
> explicit operator bool() const noexcept
> { return get() == pointer() ? false : true; }
>
>
> pointer
> release() noexcept
> {
> pointer __p = get();
> std::get<0>(_M_t) = pointer();
> return __p;
> }
>
> void
> reset() noexcept
> { reset(pointer()); }
>
> void
> reset(pointer __p) noexcept
> {
> using std::swap;
> swap(std::get<0>(_M_t), __p);
> if (__p != nullptr)
> get_deleter()(__p);
> }
>
> template<typename _Up, typename = _Require<is_pointer<pointer>,
> is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
> void reset(_Up*) = delete;
>
> void
> swap(unique_ptr& __u) noexcept
> {
> using std::swap;
> swap(_M_t, __u._M_t);
> }
>
>
> unique_ptr(const unique_ptr&) = delete;
> unique_ptr& operator=(const unique_ptr&) = delete;
>
>
> template<typename _Up, typename = _Require<is_pointer<pointer>,
> is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
> unique_ptr(_Up*, typename
> conditional<is_reference<deleter_type>::value,
> deleter_type, const deleter_type&>::type) = delete;
>
> template<typename _Up, typename = _Require<is_pointer<pointer>,
> is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
> unique_ptr(_Up*, typename
> remove_reference<deleter_type>::type&&) = delete;
> };
>
> template<typename _Tp, typename _Dp>
> inline void
> swap(unique_ptr<_Tp, _Dp>& __x,
> unique_ptr<_Tp, _Dp>& __y) noexcept
> { __x.swap(__y); }
>
> template<typename _Tp, typename _Dp,
> typename _Up, typename _Ep>
> inline bool
> operator==(const unique_ptr<_Tp, _Dp>& __x,
> const unique_ptr<_Up, _Ep>& __y)
> { return __x.get() == __y.get(); }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
> { return !__x; }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
> { return !__x; }
>
> template<typename _Tp, typename _Dp,
> typename _Up, typename _Ep>
> inline bool
> operator!=(const unique_ptr<_Tp, _Dp>& __x,
> const unique_ptr<_Up, _Ep>& __y)
> { return __x.get() != __y.get(); }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
> { return (bool)__x; }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
> { return (bool)__x; }
>
> template<typename _Tp, typename _Dp,
> typename _Up, typename _Ep>
> inline bool
> operator<(const unique_ptr<_Tp, _Dp>& __x,
> const unique_ptr<_Up, _Ep>& __y)
> {
> typedef typename
> std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
> typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
> return std::less<_CT>()(__x.get(), __y.get());
> }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
> { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
> nullptr); }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
> { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
> __x.get()); }
>
> template<typename _Tp, typename _Dp,
> typename _Up, typename _Ep>
> inline bool
> operator<=(const unique_ptr<_Tp, _Dp>& __x,
> const unique_ptr<_Up, _Ep>& __y)
> { return !(__y < __x); }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
> { return !(nullptr < __x); }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
> { return !(__x < nullptr); }
>
> template<typename _Tp, typename _Dp,
> typename _Up, typename _Ep>
> inline bool
> operator>(const unique_ptr<_Tp, _Dp>& __x,
> const unique_ptr<_Up, _Ep>& __y)
> { return (__y < __x); }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
> { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
> __x.get()); }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
> { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
> nullptr); }
>
> template<typename _Tp, typename _Dp,
> typename _Up, typename _Ep>
> inline bool
> operator>=(const unique_ptr<_Tp, _Dp>& __x,
> const unique_ptr<_Up, _Ep>& __y)
> { return !(__x < __y); }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
> { return !(__x < nullptr); }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
> { return !(nullptr < __x); }
>
>
> template<typename _Tp, typename _Dp>
> struct hash<unique_ptr<_Tp, _Dp>>
> : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>
> {
> size_t
> operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
> {
> typedef unique_ptr<_Tp, _Dp> _UP;
> return std::hash<typename _UP::pointer>()(__u.get());
> }
> };
>
>
>
>
>}
># 82 "/usr/include/c++/4.8.2/memory" 2 3
># 1 "/usr/include/c++/4.8.2/bits/shared_ptr.h" 1 3
># 52 "/usr/include/c++/4.8.2/bits/shared_ptr.h" 3
># 1 "/usr/include/c++/4.8.2/bits/shared_ptr_base.h" 1 3
># 52 "/usr/include/c++/4.8.2/bits/shared_ptr_base.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename> class auto_ptr;
>
>
>
>
>
>
> class bad_weak_ptr : public std::exception
> {
> public:
> virtual char const*
> what() const noexcept;
>
> virtual ~bad_weak_ptr() noexcept;
> };
>
>
> inline void
> __throw_bad_weak_ptr()
> { (throw (bad_weak_ptr())); }
>
> using __gnu_cxx::_Lock_policy;
> using __gnu_cxx::__default_lock_policy;
> using __gnu_cxx::_S_single;
> using __gnu_cxx::_S_mutex;
> using __gnu_cxx::_S_atomic;
>
>
> template<_Lock_policy _Lp>
> class _Mutex_base
> {
> protected:
>
> enum { _S_need_barriers = 0 };
> };
>
> template<>
> class _Mutex_base<_S_mutex>
> : public __gnu_cxx::__mutex
> {
> protected:
>
>
>
> enum { _S_need_barriers = 1 };
> };
>
> template<_Lock_policy _Lp = __default_lock_policy>
> class _Sp_counted_base
> : public _Mutex_base<_Lp>
> {
> public:
> _Sp_counted_base() noexcept
> : _M_use_count(1), _M_weak_count(1) { }
>
> virtual
> ~_Sp_counted_base() noexcept
> { }
>
>
>
> virtual void
> _M_dispose() noexcept = 0;
>
>
> virtual void
> _M_destroy() noexcept
> { delete this; }
>
> virtual void*
> _M_get_deleter(const std::type_info&) = 0;
>
> void
> _M_add_ref_copy()
> { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }
>
> void
> _M_add_ref_lock();
>
> void
> _M_release() noexcept
> {
>
> ;
> if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
> {
> ;
> _M_dispose();
>
>
>
>
> if (_Mutex_base<_Lp>::_S_need_barriers)
> {
> __asm __volatile ("":::"memory");
> __asm __volatile ("":::"memory");
> }
>
>
> ;
> if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
> -1) == 1)
> {
> ;
> _M_destroy();
> }
> }
> }
>
> void
> _M_weak_add_ref() noexcept
> { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
>
> void
> _M_weak_release() noexcept
> {
>
> ;
> if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
> {
> ;
> if (_Mutex_base<_Lp>::_S_need_barriers)
> {
>
>
> __asm __volatile ("":::"memory");
> __asm __volatile ("":::"memory");
> }
> _M_destroy();
> }
> }
>
> long
> _M_get_use_count() const noexcept
> {
>
>
> return __atomic_load_n(&_M_use_count, 0);
> }
>
> private:
> _Sp_counted_base(_Sp_counted_base const&) = delete;
> _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;
>
> _Atomic_word _M_use_count;
> _Atomic_word _M_weak_count;
> };
>
> template<>
> inline void
> _Sp_counted_base<_S_single>::
> _M_add_ref_lock()
> {
> if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
> {
> _M_use_count = 0;
> __throw_bad_weak_ptr();
> }
> }
>
> template<>
> inline void
> _Sp_counted_base<_S_mutex>::
> _M_add_ref_lock()
> {
> __gnu_cxx::__scoped_lock sentry(*this);
> if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
> {
> _M_use_count = 0;
> __throw_bad_weak_ptr();
> }
> }
>
> template<>
> inline void
> _Sp_counted_base<_S_atomic>::
> _M_add_ref_lock()
> {
>
> _Atomic_word __count = _M_use_count;
> do
> {
> if (__count == 0)
> __throw_bad_weak_ptr();
>
>
> }
> while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
> true, 4,
> 0));
> }
>
>
>
> template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
> class __shared_ptr;
>
> template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
> class __weak_ptr;
>
> template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
> class __enable_shared_from_this;
>
> template<typename _Tp>
> class shared_ptr;
>
> template<typename _Tp>
> class weak_ptr;
>
> template<typename _Tp>
> struct owner_less;
>
> template<typename _Tp>
> class enable_shared_from_this;
>
> template<_Lock_policy _Lp = __default_lock_policy>
> class __weak_count;
>
> template<_Lock_policy _Lp = __default_lock_policy>
> class __shared_count;
>
>
>
> template<typename _Ptr, _Lock_policy _Lp>
> class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
> {
> public:
> explicit
> _Sp_counted_ptr(_Ptr __p)
> : _M_ptr(__p) { }
>
> virtual void
> _M_dispose() noexcept
> { delete _M_ptr; }
>
> virtual void
> _M_destroy() noexcept
> { delete this; }
>
> virtual void*
> _M_get_deleter(const std::type_info&)
> { return 0; }
>
> _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
> _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;
>
> protected:
> _Ptr _M_ptr;
> };
>
> template<>
> inline void
> _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }
>
> template<>
> inline void
> _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }
>
> template<>
> inline void
> _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }
>
>
> template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
> class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
> {
>
>
>
> struct _My_Deleter
> : public _Alloc
> {
> _Deleter _M_del;
> _My_Deleter(_Deleter __d, const _Alloc& __a)
> : _Alloc(__a), _M_del(__d) { }
> };
>
> public:
>
> _Sp_counted_deleter(_Ptr __p, _Deleter __d)
> : _M_ptr(__p), _M_del(__d, _Alloc()) { }
>
>
> _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a)
> : _M_ptr(__p), _M_del(__d, __a) { }
>
> ~_Sp_counted_deleter() noexcept { }
>
> virtual void
> _M_dispose() noexcept
> { _M_del._M_del(_M_ptr); }
>
> virtual void
> _M_destroy() noexcept
> {
> typedef typename allocator_traits<_Alloc>::template
> rebind_traits<_Sp_counted_deleter> _Alloc_traits;
> typename _Alloc_traits::allocator_type __a(_M_del);
> _Alloc_traits::destroy(__a, this);
> _Alloc_traits::deallocate(__a, this, 1);
> }
>
> virtual void*
> _M_get_deleter(const std::type_info& __ti)
> {
>
> return __ti == typeid(_Deleter) ? &_M_del._M_del : 0;
>
>
>
> }
>
> protected:
> _Ptr _M_ptr;
> _My_Deleter _M_del;
> };
>
>
>
> struct _Sp_make_shared_tag { };
>
> template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
> class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
> {
>
>
>
> struct _Impl
> : public _Alloc
> {
> _Impl(_Alloc __a) : _Alloc(__a), _M_ptr() { }
> _Tp* _M_ptr;
> };
>
> public:
> template<typename... _Args>
> _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
> : _M_impl(__a)
> {
> _M_impl._M_ptr = static_cast<_Tp*>(static_cast<void*>(&_M_storage));
>
>
> allocator_traits<_Alloc>::construct(__a, _M_impl._M_ptr,
> std::forward<_Args>(__args)...);
> }
>
> ~_Sp_counted_ptr_inplace() noexcept { }
>
> virtual void
> _M_dispose() noexcept
> { allocator_traits<_Alloc>::destroy(_M_impl, _M_impl._M_ptr); }
>
>
> virtual void
> _M_destroy() noexcept
> {
> typedef typename allocator_traits<_Alloc>::template
> rebind_traits<_Sp_counted_ptr_inplace> _Alloc_traits;
> typename _Alloc_traits::allocator_type __a(_M_impl);
> _Alloc_traits::destroy(__a, this);
> _Alloc_traits::deallocate(__a, this, 1);
> }
>
>
> virtual void*
> _M_get_deleter(const std::type_info& __ti) noexcept
> {
>
> return __ti == typeid(_Sp_make_shared_tag)
> ? static_cast<void*>(&_M_storage)
> : 0;
>
>
>
> }
>
> private:
> _Impl _M_impl;
> typename aligned_storage<sizeof(_Tp), alignment_of<_Tp>::value>::type
> _M_storage;
> };
>
> template<_Lock_policy _Lp>
> class __shared_count
> {
> public:
> constexpr __shared_count() noexcept : _M_pi(0)
> { }
>
> template<typename _Ptr>
> explicit
> __shared_count(_Ptr __p) : _M_pi(0)
> {
> try
> {
> _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
> }
> catch(...)
> {
> delete __p;
> throw;
> }
> }
>
> template<typename _Ptr, typename _Deleter>
> __shared_count(_Ptr __p, _Deleter __d)
> : __shared_count(__p, std::move(__d), allocator<int>())
> { }
>
> template<typename _Ptr, typename _Deleter, typename _Alloc>
> __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
> {
> typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
> typedef typename allocator_traits<_Alloc>::template
> rebind_traits<_Sp_cd_type> _Alloc_traits;
> typename _Alloc_traits::allocator_type __a2(__a);
> _Sp_cd_type* __mem = 0;
> try
> {
> __mem = _Alloc_traits::allocate(__a2, 1);
> _Alloc_traits::construct(__a2, __mem,
> __p, std::move(__d), std::move(__a));
> _M_pi = __mem;
> }
> catch(...)
> {
> __d(__p);
> if (__mem)
> _Alloc_traits::deallocate(__a2, __mem, 1);
> throw;
> }
> }
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> __shared_count(_Sp_make_shared_tag, _Tp*, const _Alloc& __a,
> _Args&&... __args)
> : _M_pi(0)
> {
> typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
> typedef typename allocator_traits<_Alloc>::template
> rebind_traits<_Sp_cp_type> _Alloc_traits;
> typename _Alloc_traits::allocator_type __a2(__a);
> _Sp_cp_type* __mem = _Alloc_traits::allocate(__a2, 1);
> try
> {
> _Alloc_traits::construct(__a2, __mem, std::move(__a),
> std::forward<_Args>(__args)...);
> _M_pi = __mem;
> }
> catch(...)
> {
> _Alloc_traits::deallocate(__a2, __mem, 1);
> throw;
> }
> }
>
>
>
> template<typename _Tp>
> explicit
> __shared_count(std::auto_ptr<_Tp>&& __r);
>
>
>
> template<typename _Tp, typename _Del>
> explicit
> __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
> {
> using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
> using _Del2 = typename conditional<is_reference<_Del>::value,
> reference_wrapper<typename remove_reference<_Del>::type>,
> _Del>::type;
> using _Sp_cd_type
> = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
> using _Alloc = allocator<_Sp_cd_type>;
> using _Alloc_traits = allocator_traits<_Alloc>;
> _Alloc __a;
> _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
> _Alloc_traits::construct(__a, __mem, __r.release(),
> __r.get_deleter());
> _M_pi = __mem;
> }
>
>
> explicit __shared_count(const __weak_count<_Lp>& __r);
>
> ~__shared_count() noexcept
> {
> if (_M_pi != nullptr)
> _M_pi->_M_release();
> }
>
> __shared_count(const __shared_count& __r) noexcept
> : _M_pi(__r._M_pi)
> {
> if (_M_pi != 0)
> _M_pi->_M_add_ref_copy();
> }
>
> __shared_count&
> operator=(const __shared_count& __r) noexcept
> {
> _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
> if (__tmp != _M_pi)
> {
> if (__tmp != 0)
> __tmp->_M_add_ref_copy();
> if (_M_pi != 0)
> _M_pi->_M_release();
> _M_pi = __tmp;
> }
> return *this;
> }
>
> void
> _M_swap(__shared_count& __r) noexcept
> {
> _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
> __r._M_pi = _M_pi;
> _M_pi = __tmp;
> }
>
> long
> _M_get_use_count() const noexcept
> { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
>
> bool
> _M_unique() const noexcept
> { return this->_M_get_use_count() == 1; }
>
> void*
> _M_get_deleter(const std::type_info& __ti) const noexcept
> { return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0; }
>
> bool
> _M_less(const __shared_count& __rhs) const noexcept
> { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
>
> bool
> _M_less(const __weak_count<_Lp>& __rhs) const noexcept
> { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
>
>
> friend inline bool
> operator==(const __shared_count& __a, const __shared_count& __b) noexcept
> { return __a._M_pi == __b._M_pi; }
>
> private:
> friend class __weak_count<_Lp>;
>
> _Sp_counted_base<_Lp>* _M_pi;
> };
>
>
> template<_Lock_policy _Lp>
> class __weak_count
> {
> public:
> constexpr __weak_count() noexcept : _M_pi(0)
> { }
>
> __weak_count(const __shared_count<_Lp>& __r) noexcept
> : _M_pi(__r._M_pi)
> {
> if (_M_pi != 0)
> _M_pi->_M_weak_add_ref();
> }
>
> __weak_count(const __weak_count<_Lp>& __r) noexcept
> : _M_pi(__r._M_pi)
> {
> if (_M_pi != 0)
> _M_pi->_M_weak_add_ref();
> }
>
> ~__weak_count() noexcept
> {
> if (_M_pi != 0)
> _M_pi->_M_weak_release();
> }
>
> __weak_count<_Lp>&
> operator=(const __shared_count<_Lp>& __r) noexcept
> {
> _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
> if (__tmp != 0)
> __tmp->_M_weak_add_ref();
> if (_M_pi != 0)
> _M_pi->_M_weak_release();
> _M_pi = __tmp;
> return *this;
> }
>
> __weak_count<_Lp>&
> operator=(const __weak_count<_Lp>& __r) noexcept
> {
> _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
> if (__tmp != 0)
> __tmp->_M_weak_add_ref();
> if (_M_pi != 0)
> _M_pi->_M_weak_release();
> _M_pi = __tmp;
> return *this;
> }
>
> void
> _M_swap(__weak_count<_Lp>& __r) noexcept
> {
> _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
> __r._M_pi = _M_pi;
> _M_pi = __tmp;
> }
>
> long
> _M_get_use_count() const noexcept
> { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
>
> bool
> _M_less(const __weak_count& __rhs) const noexcept
> { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
>
> bool
> _M_less(const __shared_count<_Lp>& __rhs) const noexcept
> { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
>
>
> friend inline bool
> operator==(const __weak_count& __a, const __weak_count& __b) noexcept
> { return __a._M_pi == __b._M_pi; }
>
> private:
> friend class __shared_count<_Lp>;
>
> _Sp_counted_base<_Lp>* _M_pi;
> };
>
>
> template<_Lock_policy _Lp>
> inline __shared_count<_Lp>:: __shared_count(const __weak_count<_Lp>& __r)
> : _M_pi(__r._M_pi)
> {
> if (_M_pi != 0)
> _M_pi->_M_add_ref_lock();
> else
> __throw_bad_weak_ptr();
> }
>
>
>
>
>
> template<_Lock_policy _Lp, typename _Tp1, typename _Tp2>
> void
> __enable_shared_from_this_helper(const __shared_count<_Lp>&,
> const __enable_shared_from_this<_Tp1,
> _Lp>*, const _Tp2*) noexcept;
>
>
> template<typename _Tp1, typename _Tp2>
> void
> __enable_shared_from_this_helper(const __shared_count<>&,
> const enable_shared_from_this<_Tp1>*,
> const _Tp2*) noexcept;
>
> template<_Lock_policy _Lp>
> inline void
> __enable_shared_from_this_helper(const __shared_count<_Lp>&, ...) noexcept
> { }
>
>
> template<typename _Tp, _Lock_policy _Lp>
> class __shared_ptr
> {
> public:
> typedef _Tp element_type;
>
> constexpr __shared_ptr() noexcept
> : _M_ptr(0), _M_refcount()
> { }
>
> template<typename _Tp1>
> explicit __shared_ptr(_Tp1* __p)
> : _M_ptr(__p), _M_refcount(__p)
> {
> 
> static_assert( sizeof(_Tp1) > 0, "incomplete type" );
> __enable_shared_from_this_helper(_M_refcount, __p, __p);
> }
>
> template<typename _Tp1, typename _Deleter>
> __shared_ptr(_Tp1* __p, _Deleter __d)
> : _M_ptr(__p), _M_refcount(__p, __d)
> {
> 
>
> __enable_shared_from_this_helper(_M_refcount, __p, __p);
> }
>
> template<typename _Tp1, typename _Deleter, typename _Alloc>
> __shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
> : _M_ptr(__p), _M_refcount(__p, __d, std::move(__a))
> {
> 
>
> __enable_shared_from_this_helper(_M_refcount, __p, __p);
> }
>
> template<typename _Deleter>
> __shared_ptr(nullptr_t __p, _Deleter __d)
> : _M_ptr(0), _M_refcount(__p, __d)
> { }
>
> template<typename _Deleter, typename _Alloc>
> __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
> : _M_ptr(0), _M_refcount(__p, __d, std::move(__a))
> { }
>
> template<typename _Tp1>
> __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p) noexcept
> : _M_ptr(__p), _M_refcount(__r._M_refcount)
> { }
>
> __shared_ptr(const __shared_ptr&) noexcept = default;
> __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
> ~__shared_ptr() = default;
>
> template<typename _Tp1, typename = typename
> std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
> __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
> : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
> { }
>
> __shared_ptr(__shared_ptr&& __r) noexcept
> : _M_ptr(__r._M_ptr), _M_refcount()
> {
> _M_refcount._M_swap(__r._M_refcount);
> __r._M_ptr = 0;
> }
>
> template<typename _Tp1, typename = typename
> std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
> __shared_ptr(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
> : _M_ptr(__r._M_ptr), _M_refcount()
> {
> _M_refcount._M_swap(__r._M_refcount);
> __r._M_ptr = 0;
> }
>
> template<typename _Tp1>
> explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
> : _M_refcount(__r._M_refcount)
> {
> 
>
>
>
> _M_ptr = __r._M_ptr;
> }
>
>
> template<typename _Tp1, typename _Del>
> __shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
> : _M_ptr(__r.get()), _M_refcount()
> {
> 
> auto __tmp = __r.get();
> _M_refcount = __shared_count<_Lp>(std::move(__r));
> __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
> }
>
>
>
> template<typename _Tp1>
> __shared_ptr(std::auto_ptr<_Tp1>&& __r);
>
>
>
> constexpr __shared_ptr(nullptr_t) noexcept
> : _M_ptr(0), _M_refcount()
> { }
>
> template<typename _Tp1>
> __shared_ptr&
> operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
> {
> _M_ptr = __r._M_ptr;
> _M_refcount = __r._M_refcount;
> return *this;
> }
>
>
> template<typename _Tp1>
> __shared_ptr&
> operator=(std::auto_ptr<_Tp1>&& __r)
> {
> __shared_ptr(std::move(__r)).swap(*this);
> return *this;
> }
>
>
> __shared_ptr&
> operator=(__shared_ptr&& __r) noexcept
> {
> __shared_ptr(std::move(__r)).swap(*this);
> return *this;
> }
>
> template<class _Tp1>
> __shared_ptr&
> operator=(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
> {
> __shared_ptr(std::move(__r)).swap(*this);
> return *this;
> }
>
> template<typename _Tp1, typename _Del>
> __shared_ptr&
> operator=(std::unique_ptr<_Tp1, _Del>&& __r)
> {
> __shared_ptr(std::move(__r)).swap(*this);
> return *this;
> }
>
> void
> reset() noexcept
> { __shared_ptr().swap(*this); }
>
> template<typename _Tp1>
> void
> reset(_Tp1* __p)
> {
>
> ;
> __shared_ptr(__p).swap(*this);
> }
>
> template<typename _Tp1, typename _Deleter>
> void
> reset(_Tp1* __p, _Deleter __d)
> { __shared_ptr(__p, __d).swap(*this); }
>
> template<typename _Tp1, typename _Deleter, typename _Alloc>
> void
> reset(_Tp1* __p, _Deleter __d, _Alloc __a)
> { __shared_ptr(__p, __d, std::move(__a)).swap(*this); }
>
>
> typename std::add_lvalue_reference<_Tp>::type
> operator*() const noexcept
> {
> ;
> return *_M_ptr;
> }
>
> _Tp*
> operator->() const noexcept
> {
> ;
> return _M_ptr;
> }
>
> _Tp*
> get() const noexcept
> { return _M_ptr; }
>
> explicit operator bool() const
> { return _M_ptr == 0 ? false : true; }
>
> bool
> unique() const noexcept
> { return _M_refcount._M_unique(); }
>
> long
> use_count() const noexcept
> { return _M_refcount._M_get_use_count(); }
>
> void
> swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
> {
> std::swap(_M_ptr, __other._M_ptr);
> _M_refcount._M_swap(__other._M_refcount);
> }
>
> template<typename _Tp1>
> bool
> owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const
> { return _M_refcount._M_less(__rhs._M_refcount); }
>
> template<typename _Tp1>
> bool
> owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const
> { return _M_refcount._M_less(__rhs._M_refcount); }
>
>
> protected:
>
> template<typename _Alloc, typename... _Args>
> __shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
> _Args&&... __args)
> : _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
> std::forward<_Args>(__args)...)
> {
>
>
> void* __p = _M_refcount._M_get_deleter(typeid(__tag));
> _M_ptr = static_cast<_Tp*>(__p);
> __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
> }
># 1005 "/usr/include/c++/4.8.2/bits/shared_ptr_base.h" 3
> template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
> typename... _Args>
> friend __shared_ptr<_Tp1, _Lp1>
> __allocate_shared(const _Alloc& __a, _Args&&... __args);
>
> private:
> void*
> _M_get_deleter(const std::type_info& __ti) const noexcept
> { return _M_refcount._M_get_deleter(__ti); }
>
> template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
> template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
>
> template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
> friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;
>
> _Tp* _M_ptr;
> __shared_count<_Lp> _M_refcount;
> };
>
>
>
> template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
> inline bool
> operator==(const __shared_ptr<_Tp1, _Lp>& __a,
> const __shared_ptr<_Tp2, _Lp>& __b) noexcept
> { return __a.get() == __b.get(); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
> { return !__a; }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
> { return !__a; }
>
> template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
> inline bool
> operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
> const __shared_ptr<_Tp2, _Lp>& __b) noexcept
> { return __a.get() != __b.get(); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
> { return (bool)__a; }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
> { return (bool)__a; }
>
> template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
> inline bool
> operator<(const __shared_ptr<_Tp1, _Lp>& __a,
> const __shared_ptr<_Tp2, _Lp>& __b) noexcept
> {
> typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
> return std::less<_CT>()(__a.get(), __b.get());
> }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
> { return std::less<_Tp*>()(__a.get(), nullptr); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
> { return std::less<_Tp*>()(nullptr, __a.get()); }
>
> template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
> inline bool
> operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
> const __shared_ptr<_Tp2, _Lp>& __b) noexcept
> { return !(__b < __a); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
> { return !(nullptr < __a); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
> { return !(__a < nullptr); }
>
> template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
> inline bool
> operator>(const __shared_ptr<_Tp1, _Lp>& __a,
> const __shared_ptr<_Tp2, _Lp>& __b) noexcept
> { return (__b < __a); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
> { return std::less<_Tp*>()(nullptr, __a.get()); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
> { return std::less<_Tp*>()(__a.get(), nullptr); }
>
> template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
> inline bool
> operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
> const __shared_ptr<_Tp2, _Lp>& __b) noexcept
> { return !(__a < __b); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
> { return !(__a < nullptr); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
> { return !(nullptr < __a); }
>
> template<typename _Sp>
> struct _Sp_less : public binary_function<_Sp, _Sp, bool>
> {
> bool
> operator()(const _Sp& __lhs, const _Sp& __rhs) const noexcept
> {
> typedef typename _Sp::element_type element_type;
> return std::less<element_type*>()(__lhs.get(), __rhs.get());
> }
> };
>
> template<typename _Tp, _Lock_policy _Lp>
> struct less<__shared_ptr<_Tp, _Lp>>
> : public _Sp_less<__shared_ptr<_Tp, _Lp>>
> { };
>
>
> template<typename _Tp, _Lock_policy _Lp>
> inline void
> swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
> { __a.swap(__b); }
># 1155 "/usr/include/c++/4.8.2/bits/shared_ptr_base.h" 3
> template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
> inline __shared_ptr<_Tp, _Lp>
> static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
> { return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get())); }
>
>
>
>
>
>
> template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
> inline __shared_ptr<_Tp, _Lp>
> const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
> { return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get())); }
>
>
>
>
>
>
> template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
> inline __shared_ptr<_Tp, _Lp>
> dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
> {
> if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
> return __shared_ptr<_Tp, _Lp>(__r, __p);
> return __shared_ptr<_Tp, _Lp>();
> }
>
>
> template<typename _Tp, _Lock_policy _Lp>
> class __weak_ptr
> {
> public:
> typedef _Tp element_type;
>
> constexpr __weak_ptr() noexcept
> : _M_ptr(0), _M_refcount()
> { }
>
> __weak_ptr(const __weak_ptr&) noexcept = default;
> __weak_ptr& operator=(const __weak_ptr&) noexcept = default;
> ~__weak_ptr() = default;
># 1213 "/usr/include/c++/4.8.2/bits/shared_ptr_base.h" 3
> template<typename _Tp1, typename = typename
> std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
> __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
> : _M_refcount(__r._M_refcount)
> { _M_ptr = __r.lock().get(); }
>
> template<typename _Tp1, typename = typename
> std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
> __weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
> : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
> { }
>
> template<typename _Tp1>
> __weak_ptr&
> operator=(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
> {
> _M_ptr = __r.lock().get();
> _M_refcount = __r._M_refcount;
> return *this;
> }
>
> template<typename _Tp1>
> __weak_ptr&
> operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
> {
> _M_ptr = __r._M_ptr;
> _M_refcount = __r._M_refcount;
> return *this;
> }
>
> __shared_ptr<_Tp, _Lp>
> lock() const noexcept
> {
>
>
> if (expired())
> return __shared_ptr<element_type, _Lp>();
>
> try
> {
> return __shared_ptr<element_type, _Lp>(*this);
> }
> catch(const bad_weak_ptr&)
> {
>
>
>
> return __shared_ptr<element_type, _Lp>();
> }
>
>
>
>
>
>
>
> }
>
> long
> use_count() const noexcept
> { return _M_refcount._M_get_use_count(); }
>
> bool
> expired() const noexcept
> { return _M_refcount._M_get_use_count() == 0; }
>
> template<typename _Tp1>
> bool
> owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const
> { return _M_refcount._M_less(__rhs._M_refcount); }
>
> template<typename _Tp1>
> bool
> owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const
> { return _M_refcount._M_less(__rhs._M_refcount); }
>
> void
> reset() noexcept
> { __weak_ptr().swap(*this); }
>
> void
> swap(__weak_ptr& __s) noexcept
> {
> std::swap(_M_ptr, __s._M_ptr);
> _M_refcount._M_swap(__s._M_refcount);
> }
>
> private:
>
> void
> _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
> {
> _M_ptr = __ptr;
> _M_refcount = __refcount;
> }
>
> template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
> template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
> friend class __enable_shared_from_this<_Tp, _Lp>;
> friend class enable_shared_from_this<_Tp>;
>
> _Tp* _M_ptr;
> __weak_count<_Lp> _M_refcount;
> };
>
>
> template<typename _Tp, _Lock_policy _Lp>
> inline void
> swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
> { __a.swap(__b); }
>
> template<typename _Tp, typename _Tp1>
> struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __lhs, const _Tp& __rhs) const
> { return __lhs.owner_before(__rhs); }
>
> bool
> operator()(const _Tp& __lhs, const _Tp1& __rhs) const
> { return __lhs.owner_before(__rhs); }
>
> bool
> operator()(const _Tp1& __lhs, const _Tp& __rhs) const
> { return __lhs.owner_before(__rhs); }
> };
>
> template<typename _Tp, _Lock_policy _Lp>
> struct owner_less<__shared_ptr<_Tp, _Lp>>
> : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
> { };
>
> template<typename _Tp, _Lock_policy _Lp>
> struct owner_less<__weak_ptr<_Tp, _Lp>>
> : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
> { };
>
>
> template<typename _Tp, _Lock_policy _Lp>
> class __enable_shared_from_this
> {
> protected:
> constexpr __enable_shared_from_this() noexcept { }
>
> __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }
>
> __enable_shared_from_this&
> operator=(const __enable_shared_from_this&) noexcept
> { return *this; }
>
> ~__enable_shared_from_this() { }
>
> public:
> __shared_ptr<_Tp, _Lp>
> shared_from_this()
> { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
>
> __shared_ptr<const _Tp, _Lp>
> shared_from_this() const
> { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
>
> private:
> template<typename _Tp1>
> void
> _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
> { _M_weak_this._M_assign(__p, __n); }
>
> template<typename _Tp1>
> friend void
> __enable_shared_from_this_helper(const __shared_count<_Lp>& __pn,
> const __enable_shared_from_this* __pe,
> const _Tp1* __px) noexcept
> {
> if (__pe != 0)
> __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
> }
>
> mutable __weak_ptr<_Tp, _Lp> _M_weak_this;
> };
>
>
> template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
> inline __shared_ptr<_Tp, _Lp>
> __allocate_shared(const _Alloc& __a, _Args&&... __args)
> {
> return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(), __a,
> std::forward<_Args>(__args)...);
> }
>
> template<typename _Tp, _Lock_policy _Lp, typename... _Args>
> inline __shared_ptr<_Tp, _Lp>
> __make_shared(_Args&&... __args)
> {
> typedef typename std::remove_const<_Tp>::type _Tp_nc;
> return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
> std::forward<_Args>(__args)...);
> }
>
>
> template<typename _Tp, _Lock_policy _Lp>
> struct hash<__shared_ptr<_Tp, _Lp>>
> : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
> {
> size_t
> operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
> { return std::hash<_Tp*>()(__s.get()); }
> };
>
>
>}
># 53 "/usr/include/c++/4.8.2/bits/shared_ptr.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>
> template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
> inline std::basic_ostream<_Ch, _Tr>&
> operator<<(std::basic_ostream<_Ch, _Tr>& __os,
> const __shared_ptr<_Tp, _Lp>& __p)
> {
> __os << __p.get();
> return __os;
> }
>
>
> template<typename _Del, typename _Tp, _Lock_policy _Lp>
> inline _Del*
> get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
> {
>
> return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
>
>
>
> }
># 92 "/usr/include/c++/4.8.2/bits/shared_ptr.h" 3
> template<typename _Tp>
> class shared_ptr : public __shared_ptr<_Tp>
> {
> public:
>
>
>
>
> constexpr shared_ptr() noexcept
> : __shared_ptr<_Tp>() { }
>
> shared_ptr(const shared_ptr&) noexcept = default;
>
>
>
>
>
>
>
> template<typename _Tp1>
> explicit shared_ptr(_Tp1* __p)
> : __shared_ptr<_Tp>(__p) { }
># 128 "/usr/include/c++/4.8.2/bits/shared_ptr.h" 3
> template<typename _Tp1, typename _Deleter>
> shared_ptr(_Tp1* __p, _Deleter __d)
> : __shared_ptr<_Tp>(__p, __d) { }
># 145 "/usr/include/c++/4.8.2/bits/shared_ptr.h" 3
> template<typename _Deleter>
> shared_ptr(nullptr_t __p, _Deleter __d)
> : __shared_ptr<_Tp>(__p, __d) { }
># 164 "/usr/include/c++/4.8.2/bits/shared_ptr.h" 3
> template<typename _Tp1, typename _Deleter, typename _Alloc>
> shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
> : __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
># 183 "/usr/include/c++/4.8.2/bits/shared_ptr.h" 3
> template<typename _Deleter, typename _Alloc>
> shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
> : __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
># 205 "/usr/include/c++/4.8.2/bits/shared_ptr.h" 3
> template<typename _Tp1>
> shared_ptr(const shared_ptr<_Tp1>& __r, _Tp* __p) noexcept
> : __shared_ptr<_Tp>(__r, __p) { }
># 216 "/usr/include/c++/4.8.2/bits/shared_ptr.h" 3
> template<typename _Tp1, typename = typename
> std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
> shared_ptr(const shared_ptr<_Tp1>& __r) noexcept
> : __shared_ptr<_Tp>(__r) { }
>
>
>
>
>
>
> shared_ptr(shared_ptr&& __r) noexcept
> : __shared_ptr<_Tp>(std::move(__r)) { }
>
>
>
>
>
>
> template<typename _Tp1, typename = typename
> std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
> shared_ptr(shared_ptr<_Tp1>&& __r) noexcept
> : __shared_ptr<_Tp>(std::move(__r)) { }
># 247 "/usr/include/c++/4.8.2/bits/shared_ptr.h" 3
> template<typename _Tp1>
> explicit shared_ptr(const weak_ptr<_Tp1>& __r)
> : __shared_ptr<_Tp>(__r) { }
>
>
> template<typename _Tp1>
> shared_ptr(std::auto_ptr<_Tp1>&& __r);
>
>
> template<typename _Tp1, typename _Del>
> shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
> : __shared_ptr<_Tp>(std::move(__r)) { }
>
>
>
>
>
>
> constexpr shared_ptr(nullptr_t __p) noexcept
> : __shared_ptr<_Tp>(__p) { }
>
> shared_ptr& operator=(const shared_ptr&) noexcept = default;
>
> template<typename _Tp1>
> shared_ptr&
> operator=(const shared_ptr<_Tp1>& __r) noexcept
> {
> this->__shared_ptr<_Tp>::operator=(__r);
> return *this;
> }
>
>
> template<typename _Tp1>
> shared_ptr&
> operator=(std::auto_ptr<_Tp1>&& __r)
> {
> this->__shared_ptr<_Tp>::operator=(std::move(__r));
> return *this;
> }
>
>
> shared_ptr&
> operator=(shared_ptr&& __r) noexcept
> {
> this->__shared_ptr<_Tp>::operator=(std::move(__r));
> return *this;
> }
>
> template<class _Tp1>
> shared_ptr&
> operator=(shared_ptr<_Tp1>&& __r) noexcept
> {
> this->__shared_ptr<_Tp>::operator=(std::move(__r));
> return *this;
> }
>
> template<typename _Tp1, typename _Del>
> shared_ptr&
> operator=(std::unique_ptr<_Tp1, _Del>&& __r)
> {
> this->__shared_ptr<_Tp>::operator=(std::move(__r));
> return *this;
> }
>
> private:
>
> template<typename _Alloc, typename... _Args>
> shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
> _Args&&... __args)
> : __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
> { }
>
> template<typename _Tp1, typename _Alloc, typename... _Args>
> friend shared_ptr<_Tp1>
> allocate_shared(const _Alloc& __a, _Args&&... __args);
> };
>
>
> template<typename _Tp1, typename _Tp2>
> inline bool
> operator==(const shared_ptr<_Tp1>& __a,
> const shared_ptr<_Tp2>& __b) noexcept
> { return __a.get() == __b.get(); }
>
> template<typename _Tp>
> inline bool
> operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
> { return !__a; }
>
> template<typename _Tp>
> inline bool
> operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
> { return !__a; }
>
> template<typename _Tp1, typename _Tp2>
> inline bool
> operator!=(const shared_ptr<_Tp1>& __a,
> const shared_ptr<_Tp2>& __b) noexcept
> { return __a.get() != __b.get(); }
>
> template<typename _Tp>
> inline bool
> operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
> { return (bool)__a; }
>
> template<typename _Tp>
> inline bool
> operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
> { return (bool)__a; }
>
> template<typename _Tp1, typename _Tp2>
> inline bool
> operator<(const shared_ptr<_Tp1>& __a,
> const shared_ptr<_Tp2>& __b) noexcept
> {
> typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
> return std::less<_CT>()(__a.get(), __b.get());
> }
>
> template<typename _Tp>
> inline bool
> operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
> { return std::less<_Tp*>()(__a.get(), nullptr); }
>
> template<typename _Tp>
> inline bool
> operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
> { return std::less<_Tp*>()(nullptr, __a.get()); }
>
> template<typename _Tp1, typename _Tp2>
> inline bool
> operator<=(const shared_ptr<_Tp1>& __a,
> const shared_ptr<_Tp2>& __b) noexcept
> { return !(__b < __a); }
>
> template<typename _Tp>
> inline bool
> operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
> { return !(nullptr < __a); }
>
> template<typename _Tp>
> inline bool
> operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
> { return !(__a < nullptr); }
>
> template<typename _Tp1, typename _Tp2>
> inline bool
> operator>(const shared_ptr<_Tp1>& __a,
> const shared_ptr<_Tp2>& __b) noexcept
> { return (__b < __a); }
>
> template<typename _Tp>
> inline bool
> operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
> { return std::less<_Tp*>()(nullptr, __a.get()); }
>
> template<typename _Tp>
> inline bool
> operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
> { return std::less<_Tp*>()(__a.get(), nullptr); }
>
> template<typename _Tp1, typename _Tp2>
> inline bool
> operator>=(const shared_ptr<_Tp1>& __a,
> const shared_ptr<_Tp2>& __b) noexcept
> { return !(__a < __b); }
>
> template<typename _Tp>
> inline bool
> operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
> { return !(__a < nullptr); }
>
> template<typename _Tp>
> inline bool
> operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
> { return !(nullptr < __a); }
>
> template<typename _Tp>
> struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>>
> { };
>
>
> template<typename _Tp>
> inline void
> swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
> { __a.swap(__b); }
>
>
> template<typename _Tp, typename _Tp1>
> inline shared_ptr<_Tp>
> static_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
> { return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); }
>
> template<typename _Tp, typename _Tp1>
> inline shared_ptr<_Tp>
> const_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
> { return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); }
>
> template<typename _Tp, typename _Tp1>
> inline shared_ptr<_Tp>
> dynamic_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
> {
> if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
> return shared_ptr<_Tp>(__r, __p);
> return shared_ptr<_Tp>();
> }
>
>
>
>
>
>
>
> template<typename _Tp>
> class weak_ptr : public __weak_ptr<_Tp>
> {
> public:
> constexpr weak_ptr() noexcept
> : __weak_ptr<_Tp>() { }
>
> template<typename _Tp1, typename = typename
> std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
> weak_ptr(const weak_ptr<_Tp1>& __r) noexcept
> : __weak_ptr<_Tp>(__r) { }
>
> template<typename _Tp1, typename = typename
> std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
> weak_ptr(const shared_ptr<_Tp1>& __r) noexcept
> : __weak_ptr<_Tp>(__r) { }
>
> template<typename _Tp1>
> weak_ptr&
> operator=(const weak_ptr<_Tp1>& __r) noexcept
> {
> this->__weak_ptr<_Tp>::operator=(__r);
> return *this;
> }
>
> template<typename _Tp1>
> weak_ptr&
> operator=(const shared_ptr<_Tp1>& __r) noexcept
> {
> this->__weak_ptr<_Tp>::operator=(__r);
> return *this;
> }
>
> shared_ptr<_Tp>
> lock() const noexcept
> {
>
> if (this->expired())
> return shared_ptr<_Tp>();
>
> try
> {
> return shared_ptr<_Tp>(*this);
> }
> catch(const bad_weak_ptr&)
> {
> return shared_ptr<_Tp>();
> }
>
>
>
> }
> };
>
>
> template<typename _Tp>
> inline void
> swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
> { __a.swap(__b); }
>
>
>
> template<typename _Tp>
> struct owner_less;
>
>
> template<typename _Tp>
> struct owner_less<shared_ptr<_Tp>>
> : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
> { };
>
>
> template<typename _Tp>
> struct owner_less<weak_ptr<_Tp>>
> : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
> { };
>
>
>
>
> template<typename _Tp>
> class enable_shared_from_this
> {
> protected:
> constexpr enable_shared_from_this() noexcept { }
>
> enable_shared_from_this(const enable_shared_from_this&) noexcept { }
>
> enable_shared_from_this&
> operator=(const enable_shared_from_this&) noexcept
> { return *this; }
>
> ~enable_shared_from_this() { }
>
> public:
> shared_ptr<_Tp>
> shared_from_this()
> { return shared_ptr<_Tp>(this->_M_weak_this); }
>
> shared_ptr<const _Tp>
> shared_from_this() const
> { return shared_ptr<const _Tp>(this->_M_weak_this); }
>
> private:
> template<typename _Tp1>
> void
> _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
> { _M_weak_this._M_assign(__p, __n); }
>
> template<typename _Tp1>
> friend void
> __enable_shared_from_this_helper(const __shared_count<>& __pn,
> const enable_shared_from_this* __pe,
> const _Tp1* __px) noexcept
> {
> if (__pe != 0)
> __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
> }
>
> mutable weak_ptr<_Tp> _M_weak_this;
> };
># 593 "/usr/include/c++/4.8.2/bits/shared_ptr.h" 3
> template<typename _Tp, typename _Alloc, typename... _Args>
> inline shared_ptr<_Tp>
> allocate_shared(const _Alloc& __a, _Args&&... __args)
> {
> return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
> std::forward<_Args>(__args)...);
> }
># 608 "/usr/include/c++/4.8.2/bits/shared_ptr.h" 3
> template<typename _Tp, typename... _Args>
> inline shared_ptr<_Tp>
> make_shared(_Args&&... __args)
> {
> typedef typename std::remove_const<_Tp>::type _Tp_nc;
> return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
> std::forward<_Args>(__args)...);
> }
>
>
> template<typename _Tp>
> struct hash<shared_ptr<_Tp>>
> : public __hash_base<size_t, shared_ptr<_Tp>>
> {
> size_t
> operator()(const shared_ptr<_Tp>& __s) const noexcept
> { return std::hash<_Tp*>()(__s.get()); }
> };
>
>
>
>
>}
># 83 "/usr/include/c++/4.8.2/memory" 2 3
>
># 1 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 1 3
># 36 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 47 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 3
> template<typename _Tp1>
> struct auto_ptr_ref
> {
> _Tp1* _M_ptr;
>
> explicit
> auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
> } __attribute__ ((__deprecated__));
># 86 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 3
> template<typename _Tp>
> class auto_ptr
> {
> private:
> _Tp* _M_ptr;
>
> public:
>
> typedef _Tp element_type;
>
>
>
>
>
>
>
> explicit
> auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
># 112 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 3
> auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
># 124 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 3
> template<typename _Tp1>
> auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
># 135 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 3
> auto_ptr&
> operator=(auto_ptr& __a) throw()
> {
> reset(__a.release());
> return *this;
> }
># 152 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 3
> template<typename _Tp1>
> auto_ptr&
> operator=(auto_ptr<_Tp1>& __a) throw()
> {
> reset(__a.release());
> return *this;
> }
># 170 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 3
> ~auto_ptr() { delete _M_ptr; }
># 180 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 3
> element_type&
> operator*() const throw()
> {
> ;
> return *_M_ptr;
> }
>
>
>
>
>
>
>
> element_type*
> operator->() const throw()
> {
> ;
> return _M_ptr;
> }
># 210 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 3
> element_type*
> get() const throw() { return _M_ptr; }
># 224 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 3
> element_type*
> release() throw()
> {
> element_type* __tmp = _M_ptr;
> _M_ptr = 0;
> return __tmp;
> }
># 239 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 3
> void
> reset(element_type* __p = 0) throw()
> {
> if (__p != _M_ptr)
> {
> delete _M_ptr;
> _M_ptr = __p;
> }
> }
># 260 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 3
> auto_ptr(auto_ptr_ref<element_type> __ref) throw()
> : _M_ptr(__ref._M_ptr) { }
>
> auto_ptr&
> operator=(auto_ptr_ref<element_type> __ref) throw()
> {
> if (__ref._M_ptr != this->get())
> {
> delete _M_ptr;
> _M_ptr = __ref._M_ptr;
> }
> return *this;
> }
>
> template<typename _Tp1>
> operator auto_ptr_ref<_Tp1>() throw()
> { return auto_ptr_ref<_Tp1>(this->release()); }
>
> template<typename _Tp1>
> operator auto_ptr<_Tp1>() throw()
> { return auto_ptr<_Tp1>(this->release()); }
> } __attribute__ ((__deprecated__));
>
>
>
> template<>
> class auto_ptr<void>
> {
> public:
> typedef void element_type;
> } __attribute__ ((__deprecated__));
>
>
> template<_Lock_policy _Lp>
> template<typename _Tp>
> inline
> __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp>&& __r)
> : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get()))
> { __r.release(); }
>
> template<typename _Tp, _Lock_policy _Lp>
> template<typename _Tp1>
> inline
> __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r)
> : _M_ptr(__r.get()), _M_refcount()
> {
> 
> static_assert( sizeof(_Tp1) > 0, "incomplete type" );
> _Tp1* __tmp = __r.get();
> _M_refcount = __shared_count<_Lp>(std::move(__r));
> __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
> }
>
> template<typename _Tp>
> template<typename _Tp1>
> inline
> shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r)
> : __shared_ptr<_Tp>(std::move(__r)) { }
>
> template<typename _Tp, typename _Dp>
> template<typename _Up, typename>
> inline
> unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept
> : _M_t(__u.release(), deleter_type()) { }
>
>
>
>}
># 85 "/usr/include/c++/4.8.2/memory" 2 3
># 21 "/usr/include/boost/circular_buffer_fwd.hpp" 2 3 4
>
>
>
>
>namespace boost {
>
>
>
>
>
>
>
>template <class T, class Alloc = std::allocator<T> >
>class circular_buffer;
>
>template <class T, class Alloc = std::allocator<T> >
>class circular_buffer_space_optimized;
>
>
>
>}
># 19 "/usr/include/boost/circular_buffer.hpp" 2 3 4
># 1 "/usr/include/boost/detail/workaround.hpp" 1 3 4
># 20 "/usr/include/boost/circular_buffer.hpp" 2 3 4
># 30 "/usr/include/boost/circular_buffer.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 50 "/usr/include/boost/assert.hpp" 3 4
># 1 "/usr/include/assert.h" 1 3 4
># 64 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (const char *__assertion, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 51 "/usr/include/boost/assert.hpp" 2 3 4
># 81 "/usr/include/boost/assert.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstdlib" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstdlib" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstdlib" 3
># 82 "/usr/include/boost/assert.hpp" 2 3 4
># 1 "/usr/include/c++/4.8.2/iostream" 1 3 4
># 36 "/usr/include/c++/4.8.2/iostream" 3 4
> 
># 37 "/usr/include/c++/4.8.2/iostream" 3
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 60 "/usr/include/c++/4.8.2/iostream" 3
> extern istream cin;
> extern ostream cout;
> extern ostream cerr;
> extern ostream clog;
>
>
> extern wistream wcin;
> extern wostream wcout;
> extern wostream wcerr;
> extern wostream wclog;
>
>
>
>
> static ios_base::Init __ioinit;
>
>
>}
># 83 "/usr/include/boost/assert.hpp" 2 3 4
># 1 "/usr/include/boost/current_function.hpp" 1 3 4
># 22 "/usr/include/boost/current_function.hpp" 3 4
>namespace boost
>{
>
>namespace detail
>{
>
>inline void current_function_helper()
>{
># 61 "/usr/include/boost/current_function.hpp" 3 4
>}
>
>}
>
>}
># 84 "/usr/include/boost/assert.hpp" 2 3 4
>
>
>
>
>
>
>
> namespace boost
> {
> namespace assertion
> {
> namespace detail
> {
> inline void assertion_failed_msg(char const * expr, char const * msg, char const * function,
> char const * file, long line)
> {
> std::cerr
> << "***** Internal Program Error - assertion (" << expr << ") failed in "
> << function << ":\n"
> << file << '(' << line << "): " << msg << std::endl;
>
>
>
>
> std::abort();
>
> }
> }
> }
> }
># 31 "/usr/include/boost/circular_buffer.hpp" 2 3 4
># 40 "/usr/include/boost/circular_buffer.hpp" 3 4
># 1 "/usr/include/boost/static_assert.hpp" 1 3 4
># 41 "/usr/include/boost/circular_buffer.hpp" 2 3 4
># 49 "/usr/include/boost/circular_buffer.hpp" 3 4
># 1 "/usr/include/boost/detail/iterator.hpp" 1 3 4
># 54 "/usr/include/boost/detail/iterator.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/iterator" 1 3 4
># 58 "/usr/include/c++/4.8.2/iterator" 3 4
> 
># 59 "/usr/include/c++/4.8.2/iterator" 3
>
>
>
>
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/stream_iterator.h" 1 3
># 33 "/usr/include/c++/4.8.2/bits/stream_iterator.h" 3
> 
># 34 "/usr/include/c++/4.8.2/bits/stream_iterator.h" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>
> template<typename _Tp, typename _CharT = char,
> typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
> class istream_iterator
> : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
> {
> public:
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef basic_istream<_CharT, _Traits> istream_type;
>
> private:
> istream_type* _M_stream;
> _Tp _M_value;
> bool _M_ok;
>
> public:
>
> constexpr istream_iterator()
> : _M_stream(0), _M_value(), _M_ok(false) {}
>
>
> istream_iterator(istream_type& __s)
> : _M_stream(&__s)
> { _M_read(); }
>
> istream_iterator(const istream_iterator& __obj)
> : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
> _M_ok(__obj._M_ok)
> { }
>
> const _Tp&
> operator*() const
> {
>
>
> ;
> return _M_value;
> }
>
> const _Tp*
> operator->() const { return &(operator*()); }
>
> istream_iterator&
> operator++()
> {
>
>
> ;
> _M_read();
> return *this;
> }
>
> istream_iterator
> operator++(int)
> {
>
>
> ;
> istream_iterator __tmp = *this;
> _M_read();
> return __tmp;
> }
>
> bool
> _M_equal(const istream_iterator& __x) const
> { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }
>
> private:
> void
> _M_read()
> {
> _M_ok = (_M_stream && *_M_stream) ? true : false;
> if (_M_ok)
> {
> *_M_stream >> _M_value;
> _M_ok = *_M_stream ? true : false;
> }
> }
> };
>
>
> template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
> inline bool
> operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
> const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
> { return __x._M_equal(__y); }
>
>
> template <class _Tp, class _CharT, class _Traits, class _Dist>
> inline bool
> operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
> const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
> { return !__x._M_equal(__y); }
># 152 "/usr/include/c++/4.8.2/bits/stream_iterator.h" 3
> template<typename _Tp, typename _CharT = char,
> typename _Traits = char_traits<_CharT> >
> class ostream_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> public:
>
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef basic_ostream<_CharT, _Traits> ostream_type;
>
>
> private:
> ostream_type* _M_stream;
> const _CharT* _M_string;
>
> public:
>
> ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
># 183 "/usr/include/c++/4.8.2/bits/stream_iterator.h" 3
> ostream_iterator(ostream_type& __s, const _CharT* __c)
> : _M_stream(&__s), _M_string(__c) { }
>
>
> ostream_iterator(const ostream_iterator& __obj)
> : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }
>
>
>
> ostream_iterator&
> operator=(const _Tp& __value)
> {
>
>
> ;
> *_M_stream << __value;
> if (_M_string) *_M_stream << _M_string;
> return *this;
> }
>
> ostream_iterator&
> operator*()
> { return *this; }
>
> ostream_iterator&
> operator++()
> { return *this; }
>
> ostream_iterator&
> operator++(int)
> { return *this; }
> };
>
>
>
>
>}
># 67 "/usr/include/c++/4.8.2/iterator" 2 3
># 55 "/usr/include/boost/detail/iterator.hpp" 2 3 4
># 77 "/usr/include/boost/detail/iterator.hpp" 3 4
>namespace boost { namespace detail {
>
>
>template <class Iterator>
>struct iterator_traits
> : std::iterator_traits<Iterator>
>{};
>using std::distance;
>
>}}
># 50 "/usr/include/boost/circular_buffer.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_convertible.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
># 1 "/usr/include/boost/type_traits/intrinsics.hpp" 1 3 4
># 12 "/usr/include/boost/type_traits/intrinsics.hpp" 3 4
># 1 "/usr/include/boost/type_traits/config.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/intrinsics.hpp" 2 3 4
># 205 "/usr/include/boost/type_traits/intrinsics.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_same.hpp" 1 3 4
># 31 "/usr/include/boost/type_traits/is_same.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 10 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 3 4
># 1 "/usr/include/boost/mpl/int.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/int.hpp" 3 4
># 1 "/usr/include/boost/mpl/int_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/int_fwd.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/adl.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/config/adl.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/msvc.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/intel.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/gcc.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/workaround.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
># 18 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 2 3 4
># 33 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 3 4
>namespace mpl_ { namespace aux {} }
>namespace boost { namespace mpl { using namespace mpl_;
>namespace aux { using namespace mpl_::aux; }
>}}
># 18 "/usr/include/boost/mpl/int_fwd.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/nttp.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 2 3 4
># 19 "/usr/include/boost/mpl/int_fwd.hpp" 2 3 4
>
>namespace mpl_ {
>
>template< int N > struct int_;
>
>}
>namespace boost { namespace mpl { using ::mpl_::int_; } }
># 18 "/usr/include/boost/mpl/int.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
># 16 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
># 1 "/usr/include/boost/mpl/integral_c_tag.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/integral_c_tag.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/static_constant.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/integral_c_tag.hpp" 2 3 4
>
>namespace mpl_ {
>struct integral_c_tag { static const int value = 0; };
>}
>namespace boost { namespace mpl { using ::mpl_::integral_c_tag; } }
># 17 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/static_cast.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/preprocessor/cat.hpp" 1 3 4
># 17 "/usr/include/boost/preprocessor/cat.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/cat.hpp" 2 3 4
># 23 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 2 3 4
># 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
>namespace mpl_ {
>
>template< int N >
>struct int_
>{
> static const int value = N;
>
>
>
>
>
> typedef int_ type;
>
> typedef int value_type;
> typedef integral_c_tag tag;
># 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
> typedef mpl_::int_< static_cast<int>((value + 1)) > next;
> typedef mpl_::int_< static_cast<int>((value - 1)) > prior;
>
>
>
>
>
>
> operator int() const { return static_cast<int>(this->value); }
>};
>
>
>template< int N >
>int const mpl_::int_< N >::value;
>
>
>}
># 21 "/usr/include/boost/mpl/int.hpp" 2 3 4
># 11 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/template_arity_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/template_arity_fwd.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>template< typename F > struct template_arity;
>
>}}}
># 12 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/preprocessor.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
># 45 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/comma_if.hpp" 1 3 4
># 15 "/usr/include/boost/preprocessor/comma_if.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/control/if.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/control/if.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/control/iif.hpp" 1 3 4
># 19 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/logical/bool.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
># 19 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/facilities/empty.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/punctuation/comma.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
># 16 "/usr/include/boost/preprocessor/comma_if.hpp" 2 3 4
># 46 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/repeat.hpp" 1 3 4
># 15 "/usr/include/boost/preprocessor/repeat.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 1 3 4
># 19 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/debug/error.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/tuple/eat.hpp" 1 3 4
># 22 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
># 16 "/usr/include/boost/preprocessor/repeat.hpp" 2 3 4
># 47 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/inc.hpp" 1 3 4
># 15 "/usr/include/boost/preprocessor/inc.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/arithmetic/inc.hpp" 1 3 4
># 16 "/usr/include/boost/preprocessor/inc.hpp" 2 3 4
># 48 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
># 13 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/ttp.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/ctps.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 2 3 4
># 14 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/overload_resolution.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 2 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/integral_constant.hpp" 1 3 4
># 10 "/usr/include/boost/type_traits/integral_constant.hpp" 3 4
># 1 "/usr/include/boost/mpl/bool.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/bool.hpp" 3 4
># 1 "/usr/include/boost/mpl/bool_fwd.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/bool_fwd.hpp" 3 4
>namespace mpl_ {
>
>template< bool C_ > struct bool_;
>
>
>typedef bool_<true> true_;
>typedef bool_<false> false_;
>
>}
>
>namespace boost { namespace mpl { using ::mpl_::bool_; } }
>namespace boost { namespace mpl { using ::mpl_::true_; } }
>namespace boost { namespace mpl { using ::mpl_::false_; } }
># 18 "/usr/include/boost/mpl/bool.hpp" 2 3 4
>
>
>
>namespace mpl_ {
>
>template< bool C_ > struct bool_
>{
> static const bool value = C_;
> typedef integral_c_tag tag;
> typedef bool_ type;
> typedef bool value_type;
> operator bool() const { return this->value; }
>};
>
>
>template< bool C_ >
>bool const bool_<C_>::value;
>
>
>}
># 11 "/usr/include/boost/type_traits/integral_constant.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/integral_c.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/integral_c.hpp" 3 4
># 1 "/usr/include/boost/mpl/integral_c_fwd.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/integral_c_fwd.hpp" 3 4
>namespace mpl_ {
>
>
>
>
>
>template< typename T, T N > struct integral_c;
>
>
>}
>namespace boost { namespace mpl { using ::mpl_::integral_c; } }
># 18 "/usr/include/boost/mpl/integral_c.hpp" 2 3 4
># 32 "/usr/include/boost/mpl/integral_c.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
># 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
>namespace mpl_ {
>
>template< typename T, T N >
>struct integral_c
>{
> static const T value = N;
>
>
>
>
>
> typedef integral_c type;
>
> typedef T value_type;
> typedef integral_c_tag tag;
># 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
> typedef integral_c< T, static_cast<T>((value + 1)) > next;
> typedef integral_c< T, static_cast<T>((value - 1)) > prior;
>
>
>
>
>
>
> operator T() const { return static_cast<T>(this->value); }
>};
>
>
>template< typename T, T N >
>T const integral_c< T, N >::value;
>
>
>}
># 33 "/usr/include/boost/mpl/integral_c.hpp" 2 3 4
>
>
>
>
>namespace mpl_ {
>
>template< bool C >
>struct integral_c<bool, C>
>{
> static const bool value = C;
> typedef integral_c_tag tag;
> typedef integral_c type;
> typedef bool value_type;
> operator bool() const { return this->value; }
>};
>}
># 12 "/usr/include/boost/type_traits/integral_constant.hpp" 2 3 4
>
>namespace boost{
>
>
>
>
>template <class T, T val>
>
>struct integral_constant : public mpl::integral_c<T, val>
>{
> typedef integral_constant<T,val> type;
>};
>
>template<> struct integral_constant<bool,true> : public mpl::true_
>{
>
>
>
>
>
>
>
> typedef integral_constant<bool,true> type;
>};
>template<> struct integral_constant<bool,false> : public mpl::false_
>{
>
>
>
>
>
>
>
> typedef integral_constant<bool,false> type;
>};
>
>typedef integral_constant<bool,true> true_type;
>typedef integral_constant<bool,false> false_type;
>
>}
># 16 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/aux_/lambda_support.hpp" 1 3 4
># 18 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 32 "/usr/include/boost/type_traits/is_same.hpp" 2 3 4
>
>namespace boost {
>
>
>
>template< typename T, typename U > struct is_same : public ::boost::integral_constant<bool,false> { public: };
>template< typename T > struct is_same< T,T > : public ::boost::integral_constant<bool,true> { public: };
># 98 "/usr/include/boost/type_traits/is_same.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 101 "/usr/include/boost/type_traits/is_same.hpp" 2 3 4
># 206 "/usr/include/boost/type_traits/intrinsics.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_reference.hpp" 1 3 4
># 16 "/usr/include/boost/type_traits/is_reference.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 1 3 4
># 32 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 33 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 2 3 4
>
>namespace boost {
>
>
>
>
>
>template< typename T > struct is_lvalue_reference : public ::boost::integral_constant<bool,false> { public: };
>template< typename T > struct is_lvalue_reference< T& > : public ::boost::integral_constant<bool,true> { public: };
># 113 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 116 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 2 3 4
># 17 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_rvalue_reference.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/is_rvalue_reference.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 16 "/usr/include/boost/type_traits/is_rvalue_reference.hpp" 2 3 4
>
>namespace boost {
>
>template< typename T > struct is_rvalue_reference : public ::boost::integral_constant<bool,false> { public: };
>
>template< typename T > struct is_rvalue_reference< T&& > : public ::boost::integral_constant<bool,true> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 27 "/usr/include/boost/type_traits/is_rvalue_reference.hpp" 2 3 4
># 18 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/ice.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/ice.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/yes_no_type.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/yes_no_type.hpp" 3 4
>namespace boost {
>namespace type_traits {
>
>typedef char yes_type;
>struct no_type
>{
> char padding[8];
>};
>
>}
>}
># 15 "/usr/include/boost/type_traits/ice.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/detail/ice_or.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/detail/ice_or.hpp" 3 4
>namespace boost {
>namespace type_traits {
>
>template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
>struct ice_or;
>
>template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
>struct ice_or
>{
> static const bool value = true;
>};
>
>template <>
>struct ice_or<false, false, false, false, false, false, false>
>{
> static const bool value = false;
>};
>
>}
>}
># 16 "/usr/include/boost/type_traits/ice.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/detail/ice_and.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/ice_and.hpp" 3 4
>namespace boost {
>namespace type_traits {
>
>template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
>struct ice_and;
>
>template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
>struct ice_and
>{
> static const bool value = false;
>};
>
>template <>
>struct ice_and<true, true, true, true, true, true, true>
>{
> static const bool value = true;
>};
>
>}
>}
># 17 "/usr/include/boost/type_traits/ice.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/detail/ice_not.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/detail/ice_not.hpp" 3 4
>namespace boost {
>namespace type_traits {
>
>template <bool b>
>struct ice_not
>{
> static const bool value = true;
>};
>
>template <>
>struct ice_not<true>
>{
> static const bool value = false;
>};
>
>}
>}
># 18 "/usr/include/boost/type_traits/ice.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/detail/ice_eq.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/detail/ice_eq.hpp" 3 4
>namespace boost {
>namespace type_traits {
>
>template <int b1, int b2>
>struct ice_eq
>{
> static const bool value = (b1 == b2);
>};
>
>template <int b1, int b2>
>struct ice_ne
>{
> static const bool value = (b1 != b2);
>};
>
>
>template <int b1, int b2> bool const ice_eq<b1,b2>::value;
>template <int b1, int b2> bool const ice_ne<b1,b2>::value;
>
>
>}
>}
># 19 "/usr/include/boost/type_traits/ice.hpp" 2 3 4
># 19 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 22 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
>
>template <typename T>
>struct is_reference_impl
>{
> static const bool value = (::boost::type_traits::ice_or< ::boost::is_lvalue_reference<T>::value, ::boost::is_rvalue_reference<T>::value >::value)
>
>
> ;
>};
>
>}
>
>template< typename T > struct is_reference : public ::boost::integral_constant<bool,::boost::detail::is_reference_impl<T>::value> { public: };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 43 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4
># 207 "/usr/include/boost/type_traits/intrinsics.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_volatile.hpp" 1 3 4
># 28 "/usr/include/boost/type_traits/is_volatile.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/cv_traits_impl.hpp" 1 3 4
># 23 "/usr/include/boost/type_traits/detail/cv_traits_impl.hpp" 3 4
>namespace boost {
>namespace detail {
>
>
>
>
>
>
>
>template <typename T> struct cv_traits_imp {};
>
>template <typename T>
>struct cv_traits_imp<T*>
>{
> static const bool is_const = false;
> static const bool is_volatile = false;
> typedef T unqualified_type;
>};
>
>template <typename T>
>struct cv_traits_imp<const T*>
>{
> static const bool is_const = true;
> static const bool is_volatile = false;
> typedef T unqualified_type;
>};
>
>template <typename T>
>struct cv_traits_imp<volatile T*>
>{
> static const bool is_const = false;
> static const bool is_volatile = true;
> typedef T unqualified_type;
>};
>
>template <typename T>
>struct cv_traits_imp<const volatile T*>
>{
> static const bool is_const = true;
> static const bool is_volatile = true;
> typedef T unqualified_type;
>};
># 92 "/usr/include/boost/type_traits/detail/cv_traits_impl.hpp" 3 4
>}
>}
># 29 "/usr/include/boost/type_traits/is_volatile.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/is_volatile.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 41 "/usr/include/boost/type_traits/is_volatile.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail{
>template <class T>
>struct is_volatile_rval_filter
>{
>
>
>
> static const bool value = ::boost::detail::cv_traits_imp<T*>::is_volatile;
>
>};
>
>
>
>
>
>template <class T>
>struct is_volatile_rval_filter<T&&>
>{
> static const bool value = false;
>};
>
>}
>
>
>
>
>
>
>template< typename T > struct is_volatile : public ::boost::integral_constant<bool,::boost::detail::is_volatile_rval_filter<T>::value> { public: };
>template< typename T > struct is_volatile< T& > : public ::boost::integral_constant<bool,false> { public: };
># 148 "/usr/include/boost/type_traits/is_volatile.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 151 "/usr/include/boost/type_traits/is_volatile.hpp" 2 3 4
># 208 "/usr/include/boost/type_traits/intrinsics.hpp" 2 3 4
># 16 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/type_traits/is_array.hpp" 1 3 4
># 24 "/usr/include/boost/type_traits/is_array.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 25 "/usr/include/boost/type_traits/is_array.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 28 "/usr/include/boost/type_traits/is_array.hpp" 2 3 4
>
>namespace boost {
>
>
>
>
>template< typename T > struct is_array : public ::boost::integral_constant<bool,false> { public: };
>
>template< typename T, std::size_t N > struct is_array< T[N] > : public ::boost::integral_constant<bool,true> { public: };
>template< typename T, std::size_t N > struct is_array< T const[N] > : public ::boost::integral_constant<bool,true> { public: };
>template< typename T, std::size_t N > struct is_array< T volatile[N] > : public ::boost::integral_constant<bool,true> { public: };
>template< typename T, std::size_t N > struct is_array< T const volatile[N] > : public ::boost::integral_constant<bool,true> { public: };
>
>template< typename T > struct is_array< T[] > : public ::boost::integral_constant<bool,true> { public: };
>template< typename T > struct is_array< T const[] > : public ::boost::integral_constant<bool,true> { public: };
>template< typename T > struct is_array< T volatile[] > : public ::boost::integral_constant<bool,true> { public: };
>template< typename T > struct is_array< T const volatile[] > : public ::boost::integral_constant<bool,true> { public: };
># 87 "/usr/include/boost/type_traits/is_array.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 90 "/usr/include/boost/type_traits/is_array.hpp" 2 3 4
># 20 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/is_arithmetic.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/is_arithmetic.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_integral.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/is_integral.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 16 "/usr/include/boost/type_traits/is_integral.hpp" 2 3 4
>
>namespace boost {
>
>
>
>
>
>
>
>template< typename T > struct is_integral : public ::boost::integral_constant<bool,false> { public: };
>
>template<> struct is_integral< unsigned char > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned char const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned char volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned char const volatile > : public ::boost::integral_constant<bool,true> { public: };
>template<> struct is_integral< unsigned short > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned short const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned short volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned short const volatile > : public ::boost::integral_constant<bool,true> { public: };
>template<> struct is_integral< unsigned int > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned int const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned int volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned int const volatile > : public ::boost::integral_constant<bool,true> { public: };
>template<> struct is_integral< unsigned long > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned long const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned long volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned long const volatile > : public ::boost::integral_constant<bool,true> { public: };
>
>template<> struct is_integral< signed char > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed char const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed char volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed char const volatile > : public ::boost::integral_constant<bool,true> { public: };
>template<> struct is_integral< signed short > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed short const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed short volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed short const volatile > : public ::boost::integral_constant<bool,true> { public: };
>template<> struct is_integral< signed int > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed int const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed int volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed int const volatile > : public ::boost::integral_constant<bool,true> { public: };
>template<> struct is_integral< signed long > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed long const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed long volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed long const volatile > : public ::boost::integral_constant<bool,true> { public: };
>
>template<> struct is_integral< bool > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< bool const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< bool volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< bool const volatile > : public ::boost::integral_constant<bool,true> { public: };
>template<> struct is_integral< char > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< char const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< char volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< char const volatile > : public ::boost::integral_constant<bool,true> { public: };
>
>
>
>
>
>template<> struct is_integral< wchar_t > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< wchar_t const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< wchar_t volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< wchar_t const volatile > : public ::boost::integral_constant<bool,true> { public: };
># 65 "/usr/include/boost/type_traits/is_integral.hpp" 3 4
>template<> struct is_integral< ::boost::ulong_long_type > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< ::boost::ulong_long_type const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< ::boost::ulong_long_type volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< ::boost::ulong_long_type const volatile > : public ::boost::integral_constant<bool,true> { public: };
>template<> struct is_integral< ::boost::long_long_type > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< ::boost::long_long_type const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< ::boost::long_long_type volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< ::boost::long_long_type const volatile > : public ::boost::integral_constant<bool,true> { public: };
>
>
>
>
>
>
>template<> struct is_integral< boost::int128_type > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< boost::int128_type const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< boost::int128_type volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< boost::int128_type const volatile > : public ::boost::integral_constant<bool,true> { public: };
>template<> struct is_integral< boost::uint128_type > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< boost::uint128_type const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< boost::uint128_type volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< boost::uint128_type const volatile > : public ::boost::integral_constant<bool,true> { public: };
>
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 82 "/usr/include/boost/type_traits/is_integral.hpp" 2 3 4
># 14 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_float.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/is_float.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 14 "/usr/include/boost/type_traits/is_float.hpp" 2 3 4
>
>namespace boost {
>
>
>template< typename T > struct is_float : public ::boost::integral_constant<bool,false> { public: };
>template<> struct is_float< float > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< float const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< float volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< float const volatile > : public ::boost::integral_constant<bool,true> { public: };
>template<> struct is_float< double > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< double const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< double volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< double const volatile > : public ::boost::integral_constant<bool,true> { public: };
>template<> struct is_float< long double > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< long double const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< long double volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< long double const volatile > : public ::boost::integral_constant<bool,true> { public: };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 26 "/usr/include/boost/type_traits/is_float.hpp" 2 3 4
># 15 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 21 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4
>
>namespace boost {
>
>
>namespace detail {
>
>template< typename T >
>struct is_arithmetic_impl
>{
> static const bool value = (::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_float<T>::value >::value)
>
>
>
> ;
>};
>
>}
>
>
>
>
>
>
>template< typename T > struct is_arithmetic : public ::boost::integral_constant<bool,::boost::detail::is_arithmetic_impl<T>::value> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 50 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4
># 22 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_void.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/is_void.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 16 "/usr/include/boost/type_traits/is_void.hpp" 2 3 4
>
>namespace boost {
>
>
>
>
>
>template< typename T > struct is_void : public ::boost::integral_constant<bool,false> { public: };
>template<> struct is_void< void > : public ::boost::integral_constant<bool,true> { public: };
>
>
>template<> struct is_void< void const > : public ::boost::integral_constant<bool,true> { public: };
>template<> struct is_void< void volatile > : public ::boost::integral_constant<bool,true> { public: };
>template<> struct is_void< void const volatile > : public ::boost::integral_constant<bool,true> { public: };
>
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 37 "/usr/include/boost/type_traits/is_void.hpp" 2 3 4
># 23 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/is_abstract.hpp" 1 3 4
># 62 "/usr/include/boost/type_traits/is_abstract.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 63 "/usr/include/boost/type_traits/is_abstract.hpp" 2 3 4
>
>
>namespace boost {
>namespace detail{
>
>
>template <class T>
>struct is_abstract_imp
>{
> static const bool value = __is_abstract(T);
>};
># 141 "/usr/include/boost/type_traits/is_abstract.hpp" 3 4
>}
>
>
>template< typename T > struct is_abstract : public ::boost::integral_constant<bool,::boost::detail::is_abstract_imp<T>::value> { public: };
>
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 152 "/usr/include/boost/type_traits/is_abstract.hpp" 2 3 4
># 25 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/add_lvalue_reference.hpp" 1 3 4
># 9 "/usr/include/boost/type_traits/add_lvalue_reference.hpp" 3 4
># 1 "/usr/include/boost/type_traits/add_reference.hpp" 1 3 4
># 17 "/usr/include/boost/type_traits/add_reference.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 18 "/usr/include/boost/type_traits/add_reference.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
># 59 "/usr/include/boost/type_traits/add_reference.hpp" 3 4
>template <typename T>
>struct add_reference_rvalue_layer
>{
> typedef T& type;
>};
>
>
>template <typename T>
>struct add_reference_rvalue_layer<T&&>
>{
> typedef T&& type;
>};
>
>
>template <typename T>
>struct add_reference_impl
>{
> typedef typename add_reference_rvalue_layer<T>::type type;
>};
>
>
>template< typename T > struct add_reference_impl<T&> { public: typedef T& type; };
>
>
>
>
>
>template<> struct add_reference_impl<void> { public: typedef void type; };
>
>template<> struct add_reference_impl<void const> { public: typedef void const type; };
>template<> struct add_reference_impl<void volatile> { public: typedef void volatile type; };
>template<> struct add_reference_impl<void const volatile> { public: typedef void const volatile type; };
>
>
>}
>
>template< typename T > struct add_reference { public: typedef typename boost::detail::add_reference_impl<T>::type type; };
>
>
>
>
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 106 "/usr/include/boost/type_traits/add_reference.hpp" 2 3 4
># 10 "/usr/include/boost/type_traits/add_lvalue_reference.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 13 "/usr/include/boost/type_traits/add_lvalue_reference.hpp" 2 3 4
>
>namespace boost{
>
>template< typename T > struct add_lvalue_reference { public: typedef typename boost::add_reference<T>::type type; };
>
>
>template< typename T > struct add_lvalue_reference<T&&> { public: typedef T& type; };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/add_lvalue_reference.hpp" 2 3 4
># 27 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 1 3 4
># 19 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 20 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 2 3 4
># 34 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 3 4
>namespace boost {
>
>namespace type_traits_detail {
>
> template <typename T, bool b>
> struct add_rvalue_reference_helper
> { typedef T type; };
>
>
> template <typename T>
> struct add_rvalue_reference_helper<T, true>
> {
> typedef T&& type;
> };
>
>
> template <typename T>
> struct add_rvalue_reference_imp
> {
> typedef typename boost::type_traits_detail::add_rvalue_reference_helper
> <T, (is_void<T>::value == false && is_reference<T>::value == false) >::type type;
> };
>
>}
>
>template< typename T > struct add_rvalue_reference { public: typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type; };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 64 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 2 3 4
># 28 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_function.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/is_function.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/false_result.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/false_result.hpp" 3 4
>namespace boost {
>namespace type_traits {
>
>
>struct false_result
>{
> template <typename T> struct result_
> {
> static const bool value = false;
> };
>};
>
>}}
># 16 "/usr/include/boost/type_traits/is_function.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/type_traits/detail/is_function_ptr_helper.hpp" 1 3 4
># 26 "/usr/include/boost/type_traits/detail/is_function_ptr_helper.hpp" 3 4
>namespace boost {
>namespace type_traits {
>
>template <class R>
>struct is_function_ptr_helper
>{
> static const bool value = false;
>};
>
>
>
>
>template <class R >
>struct is_function_ptr_helper<R (*)()> { static const bool value = true; };
>
>template <class R >
>struct is_function_ptr_helper<R (*)( ...)> { static const bool value = true; };
>
>template <class R , class T0>
>struct is_function_ptr_helper<R (*)( T0)> { static const bool value = true; };
>
>template <class R , class T0>
>struct is_function_ptr_helper<R (*)( T0 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1>
>struct is_function_ptr_helper<R (*)( T0 , T1)> { static const bool value = true; };
>
>template <class R , class T0 , class T1>
>struct is_function_ptr_helper<R (*)( T0 , T1 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)> { static const bool value = true; };
>
>template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)> { static const bool value = true; };
># 203 "/usr/include/boost/type_traits/detail/is_function_ptr_helper.hpp" 3 4
>}
>}
># 20 "/usr/include/boost/type_traits/is_function.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 27 "/usr/include/boost/type_traits/is_function.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost {
>
>
>
>namespace detail {
>
>
>template<bool is_ref = true>
>struct is_function_chooser
> : public ::boost::type_traits::false_result
>{
>};
>
>template <>
>struct is_function_chooser<false>
>{
> template< typename T > struct result_
> : public ::boost::type_traits::is_function_ptr_helper<T*>
> {
> };
>};
>
>template <typename T>
>struct is_function_impl
> : public is_function_chooser< ::boost::is_reference<T>::value >
> ::template result_<T>
>{
>};
># 95 "/usr/include/boost/type_traits/is_function.hpp" 3 4
>}
>
>
>
>
>
>
>template< typename T > struct is_function : public ::boost::integral_constant<bool,::boost::detail::is_function_impl<T>::value> { public: };
>
>template< typename T > struct is_function< T&& > : public ::boost::integral_constant<bool,false> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 110 "/usr/include/boost/type_traits/is_function.hpp" 2 3 4
># 29 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
># 37 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 38 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
>
>namespace boost {
># 53 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
>namespace detail {
># 120 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
>struct any_conversion
>{
> template <typename T> any_conversion(const volatile T&);
> template <typename T> any_conversion(const T&);
> template <typename T> any_conversion(volatile T&);
> template <typename T> any_conversion(T&);
>};
>
>template <typename T> struct checker
>{
> static boost::type_traits::no_type _m_check(any_conversion ...);
> static boost::type_traits::yes_type _m_check(T, int);
>};
>
>template <typename From, typename To>
>struct is_convertible_basic_impl
>{
> typedef typename add_lvalue_reference<From>::type lvalue_type;
> typedef typename add_rvalue_reference<From>::type rvalue_type;
> static lvalue_type _m_from;
>
> static bool const value =
> sizeof( boost::detail::checker<To>::_m_check(static_cast<rvalue_type>(_m_from), 0) )
> == sizeof(::boost::type_traits::yes_type);
>
>
>
>
>
>};
># 351 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
>template <typename From, typename To>
>struct is_convertible_impl
>{
> static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::detail::is_convertible_basic_impl<From,To>::value, ::boost::is_void<To>::value >::value, ::boost::type_traits::ice_not< ::boost::is_array<To>::value >::value, ::boost::type_traits::ice_not< ::boost::is_function<To>::value >::value >::value)
># 367 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
> ;
>};
>
>
>template <bool trivial1, bool trivial2, bool abstract_target>
>struct is_convertible_impl_select
>{
> template <class From, class To>
> struct rebind
> {
> typedef is_convertible_impl<From, To> type;
> };
>};
>
>template <>
>struct is_convertible_impl_select<true, true, false>
>{
> template <class From, class To>
> struct rebind
> {
> typedef true_type type;
> };
>};
>
>template <>
>struct is_convertible_impl_select<false, false, true>
>{
> template <class From, class To>
> struct rebind
> {
> typedef false_type type;
> };
>};
>
>template <>
>struct is_convertible_impl_select<true, false, true>
>{
> template <class From, class To>
> struct rebind
> {
> typedef false_type type;
> };
>};
>
>template <typename From, typename To>
>struct is_convertible_impl_dispatch_base
>{
>
> typedef is_convertible_impl_select<
> ::boost::is_arithmetic<From>::value,
> ::boost::is_arithmetic<To>::value,
>
> ::boost::is_abstract<To>::value
>
>
>
> > selector;
>
>
>
> typedef typename selector::template rebind<From, To> isc_binder;
> typedef typename isc_binder::type type;
>};
>
>template <typename From, typename To>
>struct is_convertible_impl_dispatch
> : public is_convertible_impl_dispatch_base<From, To>::type
>{};
># 456 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
> template<> struct is_convertible_impl< void,void > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void,void const > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void,void volatile > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void,void const volatile > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const,void > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const,void volatile > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const volatile > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void volatile > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const volatile > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void volatile > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const volatile > { public: static const bool value = (true); };
># 466 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
>template< typename To > struct is_convertible_impl< void,To > { public: static const bool value = (false); };
>template< typename From > struct is_convertible_impl< From,void > { public: static const bool value = (false); };
>
>template< typename To > struct is_convertible_impl< void const,To > { public: static const bool value = (false); };
>template< typename To > struct is_convertible_impl< void volatile,To > { public: static const bool value = (false); };
>template< typename To > struct is_convertible_impl< void const volatile,To > { public: static const bool value = (false); };
>template< typename From > struct is_convertible_impl< From,void const > { public: static const bool value = (false); };
>template< typename From > struct is_convertible_impl< From,void volatile > { public: static const bool value = (false); };
>template< typename From > struct is_convertible_impl< From,void const volatile > { public: static const bool value = (false); };
>
>
>
>}
>
>template< typename From, typename To > struct is_convertible : public ::boost::integral_constant<bool,(::boost::detail::is_convertible_impl_dispatch<From,To>::value)> { public: };
>
>
>
>
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 491 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
># 51 "/usr/include/boost/circular_buffer.hpp" 2 3 4
># 63 "/usr/include/boost/circular_buffer.hpp" 3 4
># 1 "/usr/include/boost/circular_buffer/debug.hpp" 1 3 4
># 16 "/usr/include/boost/circular_buffer/debug.hpp" 3 4
>namespace boost {
>
>namespace cb_details {
>
>
>
>
>const int UNINITIALIZED = 0xcc;
>
>class debug_iterator_registry;
>
>
>
>
>
>
>
>class debug_iterator_base {
>
>private:
>
>
>
> mutable const debug_iterator_registry* m_registry;
>
>
> mutable const debug_iterator_base* m_next;
>
>public:
>
>
>
> debug_iterator_base();
>
>
> debug_iterator_base(const debug_iterator_registry* registry);
>
>
> debug_iterator_base(const debug_iterator_base& rhs);
>
>
> ~debug_iterator_base();
>
>
>
>
> debug_iterator_base& operator = (const debug_iterator_base& rhs);
>
>
> bool is_valid(const debug_iterator_registry* registry) const;
>
>
>
>
>
> void invalidate() const;
>
>
> const debug_iterator_base* next() const;
>
>
>
>
>
> void set_next(const debug_iterator_base* it) const;
>
>private:
>
>
>
> void register_self();
>
>
> void unregister_self();
>};
>
>
>
>
>
>
>
>class debug_iterator_registry {
>
>
> mutable const debug_iterator_base* m_iterators;
>
>public:
>
>
>
> debug_iterator_registry() : m_iterators(0) {}
>
>
>
>
>
> void register_iterator(const debug_iterator_base* it) const {
> it->set_next(m_iterators);
> m_iterators = it;
> }
>
>
>
>
>
> void unregister_iterator(const debug_iterator_base* it) const {
> const debug_iterator_base* previous = 0;
> for (const debug_iterator_base* p = m_iterators; p != it; previous = p, p = p->next()) {}
> remove(it, previous);
> }
>
>
> template <class Iterator>
> void invalidate_iterators(const Iterator& it) {
> const debug_iterator_base* previous = 0;
> for (const debug_iterator_base* p = m_iterators; p != 0; p = p->next()) {
> if (((Iterator*)p)->m_it == it.m_it) {
> p->invalidate();
> remove(p, previous);
> continue;
> }
> previous = p;
> }
> }
>
>
> template <class Iterator>
> void invalidate_iterators_except(const Iterator& it) {
> const debug_iterator_base* previous = 0;
> for (const debug_iterator_base* p = m_iterators; p != 0; p = p->next()) {
> if (((Iterator*)p)->m_it != it.m_it) {
> p->invalidate();
> remove(p, previous);
> continue;
> }
> previous = p;
> }
> }
>
>
> void invalidate_all_iterators() {
> for (const debug_iterator_base* p = m_iterators; p != 0; p = p->next())
> p->invalidate();
> m_iterators = 0;
> }
>
>private:
>
>
>
> void remove(const debug_iterator_base* current,
> const debug_iterator_base* previous) const {
> if (previous == 0)
> m_iterators = m_iterators->next();
> else
> previous->set_next(current->next());
> }
>};
>
>
>
>inline debug_iterator_base::debug_iterator_base() : m_registry(0), m_next(0) {}
>
>inline debug_iterator_base::debug_iterator_base(const debug_iterator_registry* registry)
>: m_registry(registry), m_next(0) {
> register_self();
>}
>
>inline debug_iterator_base::debug_iterator_base(const debug_iterator_base& rhs)
>: m_registry(rhs.m_registry), m_next(0) {
> register_self();
>}
>
>inline debug_iterator_base::~debug_iterator_base() { unregister_self(); }
>
>inline debug_iterator_base& debug_iterator_base::operator = (const debug_iterator_base& rhs) {
> if (m_registry == rhs.m_registry)
> return *this;
> unregister_self();
> m_registry = rhs.m_registry;
> register_self();
> return *this;
>}
>
>inline bool debug_iterator_base::is_valid(const debug_iterator_registry* registry) const {
> return m_registry == registry;
>}
>
>inline void debug_iterator_base::invalidate() const { m_registry = 0; }
>
>inline const debug_iterator_base* debug_iterator_base::next() const { return m_next; }
>
>inline void debug_iterator_base::set_next(const debug_iterator_base* it) const { m_next = it; }
>
>inline void debug_iterator_base::register_self() {
> if (m_registry != 0)
> m_registry->register_iterator(this);
>}
>
>inline void debug_iterator_base::unregister_self() {
> if (m_registry != 0)
> m_registry->unregister_iterator(this);
>}
>
>
>
>}
>
>}
># 64 "/usr/include/boost/circular_buffer.hpp" 2 3 4
># 1 "/usr/include/boost/circular_buffer/details.hpp" 1 3 4
># 16 "/usr/include/boost/circular_buffer/details.hpp" 3 4
># 1 "/usr/include/boost/iterator.hpp" 1 3 4
># 18 "/usr/include/boost/iterator.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 19 "/usr/include/boost/iterator.hpp" 2 3 4
>
>
>namespace boost
>{
># 39 "/usr/include/boost/iterator.hpp" 3 4
> namespace detail {
> template <class Category, class T, class Distance, class Pointer, class Reference>
>
> struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
># 51 "/usr/include/boost/iterator.hpp" 3 4
> }
>
> template <class Category, class T, class Distance = std::ptrdiff_t,
> class Pointer = T*, class Reference = T&>
> struct iterator : boost::detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
>
>}
># 17 "/usr/include/boost/circular_buffer/details.hpp" 2 3 4
># 1 "/usr/include/boost/throw_exception.hpp" 1 3 4
>
>
>
> 
># 5 "/usr/include/boost/throw_exception.hpp" 3
># 29 "/usr/include/boost/throw_exception.hpp" 3
># 1 "/usr/include/boost/exception/detail/attribute_noreturn.hpp" 1 3 4
># 30 "/usr/include/boost/throw_exception.hpp" 2 3
># 43 "/usr/include/boost/throw_exception.hpp" 3
># 1 "/usr/include/boost/exception/exception.hpp" 1 3 4
># 9 "/usr/include/boost/exception/exception.hpp" 3 4
> 
># 10 "/usr/include/boost/exception/exception.hpp" 3
>
>
>
>
>
>namespace
>boost
> {
> namespace
> exception_detail
> {
> template <class T>
> class
> refcount_ptr
> {
> public:
>
> refcount_ptr():
> px_(0)
> {
> }
>
> ~refcount_ptr()
> {
> release();
> }
>
> refcount_ptr( refcount_ptr const & x ):
> px_(x.px_)
> {
> add_ref();
> }
>
> refcount_ptr &
> operator=( refcount_ptr const & x )
> {
> adopt(x.px_);
> return *this;
> }
>
> void
> adopt( T * px )
> {
> release();
> px_=px;
> add_ref();
> }
>
> T *
> get() const
> {
> return px_;
> }
>
> private:
>
> T * px_;
>
> void
> add_ref()
> {
> if( px_ )
> px_->add_ref();
> }
>
> void
> release()
> {
> if( px_ && px_->release() )
> px_=0;
> }
> };
> }
>
>
>
> template <class Tag,class T>
> class error_info;
>
> typedef error_info<struct throw_function_,char const *> throw_function;
> typedef error_info<struct throw_file_,char const *> throw_file;
> typedef error_info<struct throw_line_,int> throw_line;
>
> template <>
> class
> error_info<throw_function_,char const *>
> {
> public:
> typedef char const * value_type;
> value_type v_;
> explicit
> error_info( value_type v ):
> v_(v)
> {
> }
> };
>
> template <>
> class
> error_info<throw_file_,char const *>
> {
> public:
> typedef char const * value_type;
> value_type v_;
> explicit
> error_info( value_type v ):
> v_(v)
> {
> }
> };
>
> template <>
> class
> error_info<throw_line_,int>
> {
> public:
> typedef int value_type;
> value_type v_;
> explicit
> error_info( value_type v ):
> v_(v)
> {
> }
> };
>
>
>
>#pragma GCC visibility push (default)
>
>
> class exception;
>
>
>#pragma GCC visibility pop
>
>
>
> template <class T>
> class shared_ptr;
>
> namespace
> exception_detail
> {
> class error_info_base;
> struct type_info_;
>
> struct
> error_info_container
> {
> virtual char const * diagnostic_information( char const * ) const = 0;
> virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
> virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
> virtual void add_ref() const = 0;
> virtual bool release() const = 0;
> virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;
>
> protected:
>
> ~error_info_container() throw()
> {
> }
> };
>
> template <class>
> struct get_info;
>
> template <>
> struct get_info<throw_function>;
>
> template <>
> struct get_info<throw_file>;
>
> template <>
> struct get_info<throw_line>;
>
> char const * get_diagnostic_information( exception const &, char const * );
>
> void copy_boost_exception( exception *, exception const * );
>
> template <class E,class Tag,class T>
> E const & set_info( E const &, error_info<Tag,T> const & );
>
> template <class E>
> E const & set_info( E const &, throw_function const & );
>
> template <class E>
> E const & set_info( E const &, throw_file const & );
>
> template <class E>
> E const & set_info( E const &, throw_line const & );
> }
>
>
>
>#pragma GCC visibility push (default)
>
>
> class
> exception
> {
> protected:
>
> exception():
> throw_function_(0),
> throw_file_(0),
> throw_line_(-1)
> {
> }
># 231 "/usr/include/boost/exception/exception.hpp" 3
> virtual ~exception() throw()
>
> = 0
>
> ;
>
>
>
>
> private:
>
> template <class E>
> friend E const & exception_detail::set_info( E const &, throw_function const & );
>
> template <class E>
> friend E const & exception_detail::set_info( E const &, throw_file const & );
>
> template <class E>
> friend E const & exception_detail::set_info( E const &, throw_line const & );
>
> template <class E,class Tag,class T>
> friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );
>
> friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
>
> template <class>
> friend struct exception_detail::get_info;
> friend struct exception_detail::get_info<throw_function>;
> friend struct exception_detail::get_info<throw_file>;
> friend struct exception_detail::get_info<throw_line>;
> friend void exception_detail::copy_boost_exception( exception *, exception const * );
>
> mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
> mutable char const * throw_function_;
> mutable char const * throw_file_;
> mutable int throw_line_;
> };
>
>
>#pragma GCC visibility pop
>
>
>
> inline
> exception::
> ~exception() throw()
> {
> }
>
> namespace
> exception_detail
> {
> template <class E>
> E const &
> set_info( E const & x, throw_function const & y )
> {
> x.throw_function_=y.v_;
> return x;
> }
>
> template <class E>
> E const &
> set_info( E const & x, throw_file const & y )
> {
> x.throw_file_=y.v_;
> return x;
> }
>
> template <class E>
> E const &
> set_info( E const & x, throw_line const & y )
> {
> x.throw_line_=y.v_;
> return x;
> }
> }
>
>
>
> namespace
> exception_detail
> {
>
>
>#pragma GCC visibility push (default)
>
>
> template <class T>
> struct
> error_info_injector:
> public T,
> public exception
> {
> explicit
> error_info_injector( T const & x ):
> T(x)
> {
> }
>
> ~error_info_injector() throw()
> {
> }
> };
>
>
>#pragma GCC visibility pop
>
>
>
> struct large_size { char c[256]; };
> large_size dispatch_boost_exception( exception const * );
>
> struct small_size { };
> small_size dispatch_boost_exception( void const * );
>
> template <class,int>
> struct enable_error_info_helper;
>
> template <class T>
> struct
> enable_error_info_helper<T,sizeof(large_size)>
> {
> typedef T type;
> };
>
> template <class T>
> struct
> enable_error_info_helper<T,sizeof(small_size)>
> {
> typedef error_info_injector<T> type;
> };
>
> template <class T>
> struct
> enable_error_info_return_type
> {
> typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch_boost_exception(static_cast<T *>(0)))>::type type;
> };
> }
>
> template <class T>
> inline
> typename
> exception_detail::enable_error_info_return_type<T>::type
> enable_error_info( T const & x )
> {
> typedef typename exception_detail::enable_error_info_return_type<T>::type rt;
> return rt(x);
> }
>
>
>
> namespace
> exception_detail
> {
>
>
>#pragma GCC visibility push (default)
>
>
> class
> clone_base
> {
> public:
>
> virtual clone_base const * clone() const = 0;
> virtual void rethrow() const = 0;
>
> virtual
> ~clone_base() throw()
> {
> }
> };
>
>
>#pragma GCC visibility pop
>
>
>
> inline
> void
> copy_boost_exception( exception * a, exception const * b )
> {
> refcount_ptr<error_info_container> data;
> if( error_info_container * d=b->data_.get() )
> data = d->clone();
> a->throw_file_ = b->throw_file_;
> a->throw_line_ = b->throw_line_;
> a->throw_function_ = b->throw_function_;
> a->data_ = data;
> }
>
> inline
> void
> copy_boost_exception( void *, void const * )
> {
> }
>
> template <class T>
> class
> clone_impl:
> public T,
> public virtual clone_base
> {
> struct clone_tag { };
> clone_impl( clone_impl const & x, clone_tag ):
> T(x)
> {
> copy_boost_exception(this,&x);
> }
>
> public:
>
> explicit
> clone_impl( T const & x ):
> T(x)
> {
> copy_boost_exception(this,&x);
> }
>
> ~clone_impl() throw()
> {
> }
>
> private:
>
> clone_base const *
> clone() const
> {
> return new clone_impl(*this,clone_tag());
> }
>
> void
> rethrow() const
> {
> throw*this;
> }
> };
> }
>
> template <class T>
> inline
> exception_detail::clone_impl<T>
> enable_current_exception( T const & x )
> {
> return exception_detail::clone_impl<T>(x);
> }
> }
># 44 "/usr/include/boost/throw_exception.hpp" 2 3
>
>
>
>
>
>
>namespace boost
>{
>
>
>
>
>
>
>inline void throw_exception_assert_compatibility( std::exception const & ) { }
>
>template<class E> __attribute__((__noreturn__)) inline void throw_exception( E const & e )
>{
>
>
> throw_exception_assert_compatibility(e);
>
>
> throw enable_current_exception(enable_error_info(e));
>
>
>
>}
>
>
>
>
> namespace
> exception_detail
> {
> template <class E>
> __attribute__((__noreturn__))
> void
> throw_exception_( E const & x, char const * current_function, char const * file, int line )
> {
> boost::throw_exception(
> set_info(
> set_info(
> set_info(
> enable_error_info(x),
> throw_function(current_function)),
> throw_file(file)),
> throw_line(line)));
> }
> }
>
>}
># 18 "/usr/include/boost/circular_buffer/details.hpp" 2 3 4
># 1 "/usr/include/boost/detail/no_exceptions_support.hpp" 1 3 4
># 19 "/usr/include/boost/circular_buffer/details.hpp" 2 3 4
>
>
>namespace boost {
>
>namespace cb_details {
>
>template <class Traits> struct nonconst_traits;
>
>template<class ForwardIterator, class Diff, class T, class Alloc>
>void uninitialized_fill_n_with_alloc(
> ForwardIterator first, Diff n, const T& item, Alloc& alloc);
>
>template<class InputIterator, class ForwardIterator, class Alloc>
>ForwardIterator uninitialized_copy_with_alloc(
> InputIterator first, InputIterator last, ForwardIterator dest, Alloc& alloc);
>
>
>
>
>
>template <class Traits>
>struct const_traits {
>
> typedef typename Traits::value_type value_type;
> typedef typename Traits::const_pointer pointer;
> typedef typename Traits::const_reference reference;
> typedef typename Traits::size_type size_type;
> typedef typename Traits::difference_type difference_type;
>
>
> typedef nonconst_traits<Traits> nonconst_self;
>};
>
>
>
>
>
>template <class Traits>
>struct nonconst_traits {
>
> typedef typename Traits::value_type value_type;
> typedef typename Traits::pointer pointer;
> typedef typename Traits::reference reference;
> typedef typename Traits::size_type size_type;
> typedef typename Traits::difference_type difference_type;
>
>
> typedef nonconst_traits<Traits> nonconst_self;
>};
>
>
>
>
>
>template <class Iterator>
>struct iterator_wrapper {
> mutable Iterator m_it;
> explicit iterator_wrapper(Iterator it) : m_it(it) {}
> Iterator operator () () const { return m_it++; }
>private:
> iterator_wrapper<Iterator>& operator = (const iterator_wrapper<Iterator>&);
>};
>
>
>
>
>
>template <class Pointer, class Value>
>struct item_wrapper {
> Value m_item;
> explicit item_wrapper(Value item) : m_item(item) {}
> Pointer operator () () const { return &m_item; }
>private:
> item_wrapper<Pointer, Value>& operator = (const item_wrapper<Pointer, Value>&);
>};
>
>
>
>
>
>template <class Value, class Alloc>
>struct assign_n {
> typedef typename Alloc::size_type size_type;
> size_type m_n;
> Value m_item;
> Alloc& m_alloc;
> assign_n(size_type n, Value item, Alloc& alloc) : m_n(n), m_item(item), m_alloc(alloc) {}
> template <class Pointer>
> void operator () (Pointer p) const {
> uninitialized_fill_n_with_alloc(p, m_n, m_item, m_alloc);
> }
>private:
> assign_n<Value, Alloc>& operator = (const assign_n<Value, Alloc>&);
>};
>
>
>
>
>
>template <class Iterator, class Alloc>
>struct assign_range {
> const Iterator& m_first;
> const Iterator& m_last;
> Alloc& m_alloc;
> assign_range(const Iterator& first, const Iterator& last, Alloc& alloc)
> : m_first(first), m_last(last), m_alloc(alloc) {}
> template <class Pointer>
> void operator () (Pointer p) const {
> uninitialized_copy_with_alloc(m_first, m_last, p, m_alloc);
> }
>private:
> assign_range<Iterator, Alloc>& operator = (const assign_range<Iterator, Alloc>&);
>};
>
>
>
>
>
>template <class Size>
>class capacity_control {
>
>
> Size m_capacity;
>
>
> Size m_min_capacity;
>
>public:
>
>
> capacity_control(Size buffer_capacity, Size min_buffer_capacity = 0)
> : m_capacity(buffer_capacity), m_min_capacity(min_buffer_capacity) {
> ((buffer_capacity >= min_buffer_capacity) ? static_cast<void> (0) : __assert_fail ("buffer_capacity >= min_buffer_capacity", "/usr/include/boost/circular_buffer/details.hpp", 151, __PRETTY_FUNCTION__));
> }
>
>
>
>
>
>
> Size capacity() const { return m_capacity; }
>
>
> Size min_capacity() const { return m_min_capacity; }
>
>
> operator Size() const { return m_capacity; }
>};
># 176 "/usr/include/boost/circular_buffer/details.hpp" 3 4
>template <class Buff, class Traits>
>struct iterator :
> public boost::iterator<
> std::random_access_iterator_tag,
> typename Traits::value_type,
> typename Traits::difference_type,
> typename Traits::pointer,
> typename Traits::reference>
>
> , public debug_iterator_base
>
>{
>
>
>
> typedef boost::iterator<
> std::random_access_iterator_tag,
> typename Traits::value_type,
> typename Traits::difference_type,
> typename Traits::pointer,
> typename Traits::reference> base_iterator;
>
>
> typedef iterator<Buff, typename Traits::nonconst_self> nonconst_self;
>
>
>
>
> typedef typename base_iterator::value_type value_type;
>
>
> typedef typename base_iterator::pointer pointer;
>
>
> typedef typename base_iterator::reference reference;
>
>
> typedef typename Traits::size_type size_type;
>
>
> typedef typename base_iterator::difference_type difference_type;
>
>
>
>
> const Buff* m_buff;
>
>
> pointer m_it;
>
>
>
>
>
>
> iterator() : m_buff(0), m_it(0) {}
>
>
>
>
> iterator(const nonconst_self& it) : debug_iterator_base(it), m_buff(it.m_buff), m_it(it.m_it) {}
>
>
>
>
>
> iterator(const Buff* cb, const pointer p) : debug_iterator_base(cb), m_buff(cb), m_it(p) {}
># 253 "/usr/include/boost/circular_buffer/details.hpp" 3 4
> iterator& operator = (const iterator& it) {
> if (this == &it)
> return *this;
>
> debug_iterator_base::operator =(it);
>
> m_buff = it.m_buff;
> m_it = it.m_it;
> return *this;
> }
>
>
>
>
> reference operator * () const {
> ((is_valid(m_buff)) ? static_cast<void> (0) : __assert_fail ("is_valid(m_buff)", "/usr/include/boost/circular_buffer/details.hpp", 268, __PRETTY_FUNCTION__));
> ((m_it != 0) ? static_cast<void> (0) : __assert_fail ("m_it != 0", "/usr/include/boost/circular_buffer/details.hpp", 269, __PRETTY_FUNCTION__));
> return *m_it;
> }
>
>
> pointer operator -> () const { return &(operator*()); }
>
>
> template <class Traits0>
> difference_type operator - (const iterator<Buff, Traits0>& it) const {
> ((is_valid(m_buff)) ? static_cast<void> (0) : __assert_fail ("is_valid(m_buff)", "/usr/include/boost/circular_buffer/details.hpp", 279, __PRETTY_FUNCTION__));
> ((it.is_valid(m_buff)) ? static_cast<void> (0) : __assert_fail ("it.is_valid(m_buff)", "/usr/include/boost/circular_buffer/details.hpp", 280, __PRETTY_FUNCTION__));
> return linearize_pointer(*this) - linearize_pointer(it);
> }
>
>
> iterator& operator ++ () {
> ((is_valid(m_buff)) ? static_cast<void> (0) : __assert_fail ("is_valid(m_buff)", "/usr/include/boost/circular_buffer/details.hpp", 286, __PRETTY_FUNCTION__));
> ((m_it != 0) ? static_cast<void> (0) : __assert_fail ("m_it != 0", "/usr/include/boost/circular_buffer/details.hpp", 287, __PRETTY_FUNCTION__));
> m_buff->increment(m_it);
> if (m_it == m_buff->m_last)
> m_it = 0;
> return *this;
> }
>
>
> iterator operator ++ (int) {
> iterator<Buff, Traits> tmp = *this;
> ++*this;
> return tmp;
> }
>
>
> iterator& operator -- () {
> ((is_valid(m_buff)) ? static_cast<void> (0) : __assert_fail ("is_valid(m_buff)", "/usr/include/boost/circular_buffer/details.hpp", 303, __PRETTY_FUNCTION__));
> ((m_it != m_buff->m_first) ? static_cast<void> (0) : __assert_fail ("m_it != m_buff->m_first", "/usr/include/boost/circular_buffer/details.hpp", 304, __PRETTY_FUNCTION__));
> if (m_it == 0)
> m_it = m_buff->m_last;
> m_buff->decrement(m_it);
> return *this;
> }
>
>
> iterator operator -- (int) {
> iterator<Buff, Traits> tmp = *this;
> --*this;
> return tmp;
> }
>
>
> iterator& operator += (difference_type n) {
> ((is_valid(m_buff)) ? static_cast<void> (0) : __assert_fail ("is_valid(m_buff)", "/usr/include/boost/circular_buffer/details.hpp", 320, __PRETTY_FUNCTION__));
> if (n > 0) {
> ((m_buff->end() - *this >= n) ? static_cast<void> (0) : __assert_fail ("m_buff->end() - *this >= n", "/usr/include/boost/circular_buffer/details.hpp", 322, __PRETTY_FUNCTION__));
> m_it = m_buff->add(m_it, n);
> if (m_it == m_buff->m_last)
> m_it = 0;
> } else if (n < 0) {
> *this -= -n;
> }
> return *this;
> }
>
>
> iterator operator + (difference_type n) const { return iterator<Buff, Traits>(*this) += n; }
>
>
> iterator& operator -= (difference_type n) {
> ((is_valid(m_buff)) ? static_cast<void> (0) : __assert_fail ("is_valid(m_buff)", "/usr/include/boost/circular_buffer/details.hpp", 337, __PRETTY_FUNCTION__));
> if (n > 0) {
> ((*this - m_buff->begin() >= n) ? static_cast<void> (0) : __assert_fail ("*this - m_buff->begin() >= n", "/usr/include/boost/circular_buffer/details.hpp", 339, __PRETTY_FUNCTION__));
> m_it = m_buff->sub(m_it == 0 ? m_buff->m_last : m_it, n);
> } else if (n < 0) {
> *this += -n;
> }
> return *this;
> }
>
>
> iterator operator - (difference_type n) const { return iterator<Buff, Traits>(*this) -= n; }
>
>
> reference operator [] (difference_type n) const { return *(*this + n); }
>
>
>
>
> template <class Traits0>
> bool operator == (const iterator<Buff, Traits0>& it) const {
> ((is_valid(m_buff)) ? static_cast<void> (0) : __assert_fail ("is_valid(m_buff)", "/usr/include/boost/circular_buffer/details.hpp", 358, __PRETTY_FUNCTION__));
> ((it.is_valid(m_buff)) ? static_cast<void> (0) : __assert_fail ("it.is_valid(m_buff)", "/usr/include/boost/circular_buffer/details.hpp", 359, __PRETTY_FUNCTION__));
> return m_it == it.m_it;
> }
>
>
> template <class Traits0>
> bool operator != (const iterator<Buff, Traits0>& it) const {
> ((is_valid(m_buff)) ? static_cast<void> (0) : __assert_fail ("is_valid(m_buff)", "/usr/include/boost/circular_buffer/details.hpp", 366, __PRETTY_FUNCTION__));
> ((it.is_valid(m_buff)) ? static_cast<void> (0) : __assert_fail ("it.is_valid(m_buff)", "/usr/include/boost/circular_buffer/details.hpp", 367, __PRETTY_FUNCTION__));
> return m_it != it.m_it;
> }
>
>
> template <class Traits0>
> bool operator < (const iterator<Buff, Traits0>& it) const {
> ((is_valid(m_buff)) ? static_cast<void> (0) : __assert_fail ("is_valid(m_buff)", "/usr/include/boost/circular_buffer/details.hpp", 374, __PRETTY_FUNCTION__));
> ((it.is_valid(m_buff)) ? static_cast<void> (0) : __assert_fail ("it.is_valid(m_buff)", "/usr/include/boost/circular_buffer/details.hpp", 375, __PRETTY_FUNCTION__));
> return linearize_pointer(*this) < linearize_pointer(it);
> }
>
>
> template <class Traits0>
> bool operator > (const iterator<Buff, Traits0>& it) const { return it < *this; }
>
>
> template <class Traits0>
> bool operator <= (const iterator<Buff, Traits0>& it) const { return !(it < *this); }
>
>
> template <class Traits0>
> bool operator >= (const iterator<Buff, Traits0>& it) const { return !(*this < it); }
>
>
>
>
> template <class Traits0>
> typename Traits0::pointer linearize_pointer(const iterator<Buff, Traits0>& it) const {
> return it.m_it == 0 ? m_buff->m_buff + m_buff->size() :
> (it.m_it < m_buff->m_first ? it.m_it + (m_buff->m_end - m_buff->m_first)
> : m_buff->m_buff + (it.m_it - m_buff->m_first));
> }
>};
>
>
>template <class Buff, class Traits>
>inline iterator<Buff, Traits>
>operator + (typename Traits::difference_type n, const iterator<Buff, Traits>& it) {
> return it + n;
>}
># 432 "/usr/include/boost/circular_buffer/details.hpp" 3 4
>template<class InputIterator, class ForwardIterator, class Alloc>
>inline ForwardIterator uninitialized_copy_with_alloc(InputIterator first, InputIterator last, ForwardIterator dest,
> Alloc& alloc) {
> ForwardIterator next = dest;
> { try {
> for (; first != last; ++first, ++dest)
> alloc.construct(dest, *first);
> } catch(...) {
> for (; next != dest; ++next)
> alloc.destroy(next);
> throw;
> }
> }
> return dest;
>}
>
>
>
>
>
>template<class ForwardIterator, class Diff, class T, class Alloc>
>inline void uninitialized_fill_n_with_alloc(ForwardIterator first, Diff n, const T& item, Alloc& alloc) {
> ForwardIterator next = first;
> { try {
> for (; n > 0; ++first, --n)
> alloc.construct(first, item);
> } catch(...) {
> for (; next != first; ++next)
> alloc.destroy(next);
> throw;
> }
> }
>}
>
>}
>
>}
># 65 "/usr/include/boost/circular_buffer.hpp" 2 3 4
># 1 "/usr/include/boost/circular_buffer/base.hpp" 1 3 4
># 16 "/usr/include/boost/circular_buffer/base.hpp" 3 4
># 1 "/usr/include/boost/call_traits.hpp" 1 3 4
># 21 "/usr/include/boost/call_traits.hpp" 3 4
># 1 "/usr/include/boost/detail/call_traits.hpp" 1 3 4
># 24 "/usr/include/boost/detail/call_traits.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 25 "/usr/include/boost/detail/call_traits.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/type_traits/is_enum.hpp" 1 3 4
># 32 "/usr/include/boost/type_traits/is_enum.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 33 "/usr/include/boost/type_traits/is_enum.hpp" 2 3 4
>
>namespace boost {
># 181 "/usr/include/boost/type_traits/is_enum.hpp" 3 4
>template< typename T > struct is_enum : public ::boost::integral_constant<bool,__is_enum(T)> { public: };
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 188 "/usr/include/boost/type_traits/is_enum.hpp" 2 3 4
># 28 "/usr/include/boost/detail/call_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_pointer.hpp" 1 3 4
># 24 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_member_pointer.hpp" 1 3 4
># 28 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 1 3 4
># 24 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 3 4
>namespace boost {
>namespace type_traits {
>
>template <typename T>
>struct is_mem_fun_pointer_impl
>{
> static const bool value = false;
>};
>
>
>
>
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)() > { static const bool value = true; };
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)( ...) > { static const bool value = true; };
>
>
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)() const > { static const bool value = true; };
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)() volatile > { static const bool value = true; };
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)() const volatile > { static const bool value = true; };
>
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)( ...) const > { static const bool value = true; };
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)( ...) volatile > { static const bool value = true; };
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)( ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0) > { static const bool value = true; };
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0) const > { static const bool value = true; };
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile > { static const bool value = true; };
># 776 "/usr/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 3 4
>}
>}
># 25 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/remove_cv.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/remove_cv.hpp" 3 4
># 1 "/usr/include/boost/type_traits/broken_compiler_spec.hpp" 1 3 4
># 95 "/usr/include/boost/type_traits/broken_compiler_spec.hpp" 3 4
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
># 15 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 27 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4
>
>namespace boost {
>
>
>
>namespace detail{
>
>template <class T>
>struct rvalue_ref_filter_rem_cv
>{
> typedef typename boost::detail::cv_traits_imp<T*>::unqualified_type type;
>};
>
>
>
>
>
>
>template <class T>
>struct rvalue_ref_filter_rem_cv<T&&>
>{
> typedef T&& type;
>};
>
>
>}
>
>
>
>template< typename T > struct remove_cv { public: typedef typename boost::detail::rvalue_ref_filter_rem_cv<T>::type type; };
>template< typename T > struct remove_cv<T&> { public: typedef T& type; };
>
>template< typename T, std::size_t N > struct remove_cv<T const[N]> { public: typedef T type[N]; };
>template< typename T, std::size_t N > struct remove_cv<T volatile[N]> { public: typedef T type[N]; };
>template< typename T, std::size_t N > struct remove_cv<T const volatile[N]> { public: typedef T type[N]; };
># 80 "/usr/include/boost/type_traits/remove_cv.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 83 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4
># 36 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 37 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4
>
>namespace boost {
>
>
>
>
>
>template< typename T > struct is_member_function_pointer : public ::boost::integral_constant<bool,::boost::type_traits::is_mem_fun_pointer_impl<typename remove_cv<T>::type>::value> { public: };
># 132 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 135 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4
># 29 "/usr/include/boost/type_traits/is_member_pointer.hpp" 2 3 4
># 39 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/is_member_pointer.hpp" 2 3 4
>
>namespace boost {
># 50 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
>template< typename T > struct is_member_pointer : public ::boost::integral_constant<bool,::boost::is_member_function_pointer<T>::value> { public: };
>template< typename T, typename U > struct is_member_pointer : public ::boost::integral_constant<bool,true> { public: };
>
>
>template< typename T, typename U > struct is_member_pointer : public ::boost::integral_constant<bool,true> { public: };
>template< typename T, typename U > struct is_member_pointer : public ::boost::integral_constant<bool,true> { public: };
>template< typename T, typename U > struct is_member_pointer : public ::boost::integral_constant<bool,true> { public: };
># 112 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 115 "/usr/include/boost/type_traits/is_member_pointer.hpp" 2 3 4
># 25 "/usr/include/boost/type_traits/is_pointer.hpp" 2 3 4
># 41 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 42 "/usr/include/boost/type_traits/is_pointer.hpp" 2 3 4
>
>namespace boost {
>
>
>
>
>
>namespace detail {
>
>template< typename T > struct is_pointer_helper
>{
> static const bool value = false;
>};
># 63 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
>template< typename T > struct is_pointer_helper<T*> { static const bool value = true; };
>
>
>
>template< typename T >
>struct is_pointer_impl
>{
># 80 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
> static const bool value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper<typename remove_cv<T>::type>::value , ::boost::type_traits::ice_not< ::boost::is_member_pointer<T>::value >::value >::value)
>
>
>
>
>
>
> ;
>
>};
>
>}
>
>template< typename T > struct is_pointer : public ::boost::integral_constant<bool,::boost::detail::is_pointer_impl<T>::value> { public: };
># 158 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 161 "/usr/include/boost/type_traits/is_pointer.hpp" 2 3 4
># 29 "/usr/include/boost/detail/call_traits.hpp" 2 3 4
>
>
>namespace boost{
>
>namespace detail{
>
>template <typename T, bool small_>
>struct ct_imp2
>{
> typedef const T& param_type;
>};
>
>template <typename T>
>struct ct_imp2<T, true>
>{
> typedef const T param_type;
>};
>
>template <typename T, bool isp, bool b1, bool b2>
>struct ct_imp
>{
> typedef const T& param_type;
>};
>
>template <typename T, bool isp, bool b2>
>struct ct_imp<T, isp, true, b2>
>{
> typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
>};
>
>template <typename T, bool isp, bool b1>
>struct ct_imp<T, isp, b1, true>
>{
> typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
>};
>
>template <typename T, bool b1, bool b2>
>struct ct_imp<T, true, b1, b2>
>{
> typedef const T param_type;
>};
>
>}
>
>template <typename T>
>struct call_traits
>{
>public:
> typedef T value_type;
> typedef T& reference;
> typedef const T& const_reference;
>
>
>
>
>
>
> typedef typename boost::detail::ct_imp<
> T,
> ::boost::is_pointer<T>::value,
> ::boost::is_arithmetic<T>::value,
> ::boost::is_enum<T>::value
> >::param_type param_type;
>};
>
>template <typename T>
>struct call_traits<T&>
>{
> typedef T& value_type;
> typedef T& reference;
> typedef const T& const_reference;
> typedef T& param_type;
>};
># 143 "/usr/include/boost/detail/call_traits.hpp" 3 4
>template <typename T, std::size_t N>
>struct call_traits<T [N]>
>{
>private:
> typedef T array_type[N];
>public:
>
> typedef const T* value_type;
> typedef array_type& reference;
> typedef const array_type& const_reference;
> typedef const T* const param_type;
>};
>
>template <typename T, std::size_t N>
>struct call_traits<const T [N]>
>{
>private:
> typedef const T array_type[N];
>public:
>
> typedef const T* value_type;
> typedef array_type& reference;
> typedef const array_type& const_reference;
> typedef const T* const param_type;
>};
>
>
>}
># 22 "/usr/include/boost/call_traits.hpp" 2 3 4
># 17 "/usr/include/boost/circular_buffer/base.hpp" 2 3 4
># 1 "/usr/include/boost/concept_check.hpp" 1 3 4
># 20 "/usr/include/boost/concept_check.hpp" 3 4
># 1 "/usr/include/boost/concept/assert.hpp" 1 3 4
># 36 "/usr/include/boost/concept/assert.hpp" 3 4
># 1 "/usr/include/boost/concept/detail/general.hpp" 1 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/concept/detail/backward_compatibility.hpp" 1 3 4
>
>
>
>
>
>
>namespace boost
>{
> namespace concepts {}
>
>
>
>
>}
># 9 "/usr/include/boost/concept/detail/general.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/concept/detail/has_constraints.hpp" 1 3 4
># 11 "/usr/include/boost/concept/detail/has_constraints.hpp" 3 4
>namespace boost { namespace concepts {
>
>namespace detail
>{
>
>
>
> typedef char yes;
> typedef char (&no)[2];
>
> template <class Model, void (Model::*)()>
> struct wrap_constraints {};
># 31 "/usr/include/boost/concept/detail/has_constraints.hpp" 3 4
> template <class Model>
> inline yes has_constraints_(Model*, wrap_constraints<Model,&Model::constraints>* = 0);
> inline no has_constraints_(...);
>
>}
>
>
>
>template <class Model>
>struct not_satisfied
>{
> static const bool value = sizeof( detail::has_constraints_((Model*)0) ) == sizeof(detail::yes)
>
> ;
> typedef mpl::bool_<value> type;
>};
>
>}}
># 13 "/usr/include/boost/concept/detail/general.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/if.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/if.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/integral.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/eti.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
># 73 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>template< typename T > struct value_type_wknd
>{
> typedef typename T::value_type type;
>};
># 87 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
>}}}
># 18 "/usr/include/boost/mpl/if.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/aux_/na_spec.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/na_spec.hpp" 3 4
># 1 "/usr/include/boost/mpl/lambda_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/lambda_fwd.hpp" 3 4
># 1 "/usr/include/boost/mpl/void_fwd.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/void_fwd.hpp" 3 4
>namespace mpl_ {
>
>struct void_;
>
>}
>namespace boost { namespace mpl { using ::mpl_::void_; } }
># 18 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/na.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/na.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/na_fwd.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/na_fwd.hpp" 3 4
>namespace mpl_ {
>
>
>struct na
>{
> typedef na type;
> enum { value = 0 };
>};
>
>}
>namespace boost { namespace mpl { using ::mpl_::na; } }
># 19 "/usr/include/boost/mpl/aux_/na.hpp" 2 3 4
>
>
>
>namespace boost { namespace mpl {
>
>template< typename T >
>struct is_na
> : false_
>{
>
>
>
>};
>
>template<>
>struct is_na<na>
> : true_
>{
>
>
>
>};
>
>template< typename T >
>struct is_not_na
> : true_
>{
>
>
>
>};
>
>template<>
>struct is_not_na<na>
> : false_
>{
>
>
>
>};
>
>
>template< typename T, typename U > struct if_na
>{
> typedef T type;
>};
>
>template< typename U > struct if_na<na,U>
>{
> typedef U type;
>};
># 93 "/usr/include/boost/mpl/aux_/na.hpp" 3 4
>}}
># 19 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/lambda_arity_param.hpp" 1 3 4
># 25 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
>
>
>namespace boost { namespace mpl {
>
>template<
> typename T = na
> , typename Tag = void_
> , typename Arity = int_< aux::template_arity<T>::value >
>
>
> >
>struct lambda;
>
>}}
># 19 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/mpl/aux_/arity.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/arity.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/dtp.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/arity.hpp" 2 3 4
># 23 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/preprocessor/enum.hpp" 1 3 4
># 28 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 3 4
># 1 "/usr/include/boost/mpl/limits/arity.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/preprocessor/logical/and.hpp" 1 3 4
># 19 "/usr/include/boost/preprocessor/logical/and.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/logical/bitand.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/logical/and.hpp" 2 3 4
># 23 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/identity.hpp" 1 3 4
># 15 "/usr/include/boost/preprocessor/identity.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/facilities/identity.hpp" 1 3 4
># 16 "/usr/include/boost/preprocessor/identity.hpp" 2 3 4
># 24 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/empty.hpp" 1 3 4
># 25 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
># 66 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 1 3 4
># 17 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/arithmetic/dec.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/preprocessor/control/while.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/control/while.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/list/fold_left.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/list/fold_left.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/control/while.hpp" 1 3 4
># 19 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
>
># 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
># 41 "/usr/include/boost/preprocessor/list/fold_left.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 1 3 4
># 17 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/control/expr_iif.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3 4
>
># 1 "/usr/include/boost/preprocessor/list/adt.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/list/adt.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 1 3 4
># 16 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/detail/check.hpp" 1 3 4
># 17 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 2 3 4
># 19 "/usr/include/boost/preprocessor/list/adt.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/logical/compl.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/list/adt.hpp" 2 3 4
># 20 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3 4
># 42 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
># 22 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/list/fold_right.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/list/fold_right.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/list/fold_right.hpp" 2 3 4
># 37 "/usr/include/boost/preprocessor/list/fold_right.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/list/reverse.hpp" 1 3 4
># 19 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 2 3 4
># 38 "/usr/include/boost/preprocessor/list/fold_right.hpp" 2 3 4
># 23 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
># 48 "/usr/include/boost/preprocessor/control/while.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/control/detail/while.hpp" 1 3 4
># 49 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
># 21 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/tuple/elem.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/tuple/elem.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/facilities/overload.hpp" 1 3 4
># 17 "/usr/include/boost/preprocessor/facilities/overload.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/variadic/size.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/facilities/overload.hpp" 2 3 4
># 21 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/tuple/rem.hpp" 1 3 4
># 22 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/variadic/elem.hpp" 1 3 4
># 23 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
># 22 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4
># 67 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/arithmetic/sub.hpp" 1 3 4
># 68 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
># 29 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
># 20 "/usr/include/boost/mpl/if.hpp" 2 3 4
>
>
>
>
>
>namespace boost { namespace mpl {
>
>
>
>template<
> bool C
> , typename T1
> , typename T2
> >
>struct if_c
>{
> typedef T1 type;
>};
>
>template<
> typename T1
> , typename T2
> >
>struct if_c<false,T1,T2>
>{
> typedef T2 type;
>};
>
>
>
>template<
> typename T1 = na
> , typename T2 = na
> , typename T3 = na
> >
>struct if_
>{
> private:
>
> typedef if_c<
>
>
>
> static_cast<bool>(T1::value)
>
> , T2
> , T3
> > almost_type_;
>
> public:
> typedef typename almost_type_::type type;
>
> 
>};
># 131 "/usr/include/boost/mpl/if.hpp" 3 4
>template<> struct if_< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : if_< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< if_< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef if_< na , na , na > result_; typedef if_< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< if_< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< if_< na , na , na > > : int_<-1> { }; }
>
>}}
># 14 "/usr/include/boost/concept/detail/general.hpp" 2 3 4
>
>
>
>
>namespace boost { namespace concepts {
>
>template <class ModelFn>
>struct requirement_;
>
>namespace detail
>{
> template <void(*)()> struct instantiate {};
>}
>
>template <class Model>
>struct requirement
>{
> static void failed() { ((Model*)0)->~Model(); }
>};
>
>struct failed {};
>
>template <class Model>
>struct requirement<failed ************ Model::************>
>{
> static void failed() { ((Model*)0)->~Model(); }
>};
>
>
>
>template <class Model>
>struct constraint
>{
> static void failed() { ((Model*)0)->constraints(); }
>};
>
>template <class Model>
>struct requirement_<void(*)(Model)>
> : mpl::if_<
> concepts::not_satisfied<Model>
> , constraint<Model>
> , requirement<failed ************ Model::************>
> >::type
>{};
># 75 "/usr/include/boost/concept/detail/general.hpp" 3 4
>}}
># 37 "/usr/include/boost/concept/assert.hpp" 2 3 4
># 21 "/usr/include/boost/concept_check.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/type_traits/conversion_traits.hpp" 1 3 4
># 24 "/usr/include/boost/concept_check.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/mpl/assert.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/assert.hpp" 3 4
># 1 "/usr/include/boost/mpl/not.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/not.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/nested_type_wknd.hpp" 1 3 4
># 25 "/usr/include/boost/mpl/aux_/nested_type_wknd.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>template< typename T > struct nested_type_wknd
> : T::type
>{
>};
>}}}
># 20 "/usr/include/boost/mpl/not.hpp" 2 3 4
>
>
>
>namespace boost { namespace mpl {
>
>namespace aux {
>
>template< long C_ >
>struct not_impl
> : bool_<!C_>
>{
>};
>
>}
>
>
>template<
> typename T = na
> >
>struct not_
> : aux::not_impl<
> ::boost::mpl::aux::nested_type_wknd<T>::value
> >
>{
> 
>};
>
>template<> struct not_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : not_< T1 > { }; }; template< typename Tag > struct lambda< not_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef not_< na > result_; typedef not_< na > type; }; namespace aux { template< typename T1 > struct template_arity< not_< T1 > > : int_<1> { }; template<> struct template_arity< not_< na > > : int_<-1> { }; }
>
>}}
># 18 "/usr/include/boost/mpl/assert.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/aux_/yes_no.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/yes_no.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/arrays.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/yes_no.hpp" 2 3 4
>
>
>
>
>namespace boost { namespace mpl { namespace aux {
>
>typedef char (&no_tag)[1];
>typedef char (&yes_tag)[2];
>
>template< bool C_ > struct yes_no_tag
>{
> typedef no_tag type;
>};
>
>template<> struct yes_no_tag<true>
>{
> typedef yes_tag type;
>};
>
>
>template< long n > struct weighted_tag
>{
>
> typedef char (&type)[n];
>
>
>
>
>};
># 56 "/usr/include/boost/mpl/aux_/yes_no.hpp" 3 4
>}}}
># 21 "/usr/include/boost/mpl/assert.hpp" 2 3 4
># 29 "/usr/include/boost/mpl/assert.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/pp_counter.hpp" 1 3 4
># 30 "/usr/include/boost/mpl/assert.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 36 "/usr/include/boost/mpl/assert.hpp" 2 3 4
># 65 "/usr/include/boost/mpl/assert.hpp" 3 4
>namespace mpl_ {
>
>struct failed {};
># 78 "/usr/include/boost/mpl/assert.hpp" 3 4
>template< bool C > struct assert { typedef void* type; };
>template<> struct assert<false> { typedef assert type; };
>
>template< bool C >
>int assertion_failed( typename assert<C>::type );
>
>template< bool C >
>struct assertion
>{
> static int failed( assert<false> );
>};
>
>template<>
>struct assertion<true>
>{
> static int failed( void* );
>};
>
>struct assert_
>{
>
> template< typename T1, typename T2 = na, typename T3 = na, typename T4 = na > struct types {};
>
> static assert_ const arg;
> enum relations { equal = 1, not_equal, greater, greater_equal, less, less_equal };
>};
># 126 "/usr/include/boost/mpl/assert.hpp" 3 4
>boost::mpl::aux::weighted_tag<1>::type operator==( assert_, assert_ );
>boost::mpl::aux::weighted_tag<2>::type operator!=( assert_, assert_ );
>boost::mpl::aux::weighted_tag<3>::type operator>( assert_, assert_ );
>boost::mpl::aux::weighted_tag<4>::type operator>=( assert_, assert_ );
>boost::mpl::aux::weighted_tag<5>::type operator<( assert_, assert_ );
>boost::mpl::aux::weighted_tag<6>::type operator<=( assert_, assert_ );
>
>template< assert_::relations r, long x, long y > struct assert_relation {};
># 170 "/usr/include/boost/mpl/assert.hpp" 3 4
>template< bool > struct assert_arg_pred_impl { typedef int type; };
>template<> struct assert_arg_pred_impl<true> { typedef void* type; };
>
>template< typename P > struct assert_arg_pred
>{
> typedef typename P::type p_type;
> typedef typename assert_arg_pred_impl< p_type::value >::type type;
>};
>
>template< typename P > struct assert_arg_pred_not
>{
> typedef typename P::type p_type;
> enum { p = !p_type::value };
> typedef typename assert_arg_pred_impl::type type;
>};
>
>template< typename Pred >
>failed ************ (Pred::************
> assert_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type )
> );
>
>template< typename Pred >
>failed ************ (boost::mpl::not_<Pred>::************
> assert_not_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type )
> );
>
>template< typename Pred >
>assert<false>
>assert_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type );
>
>template< typename Pred >
>assert<false>
>assert_not_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type );
># 245 "/usr/include/boost/mpl/assert.hpp" 3 4
>}
># 28 "/usr/include/boost/concept_check.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/concept/usage.hpp" 1 3 4
># 11 "/usr/include/boost/concept/usage.hpp" 3 4
>namespace boost { namespace concepts {
>
>
>
>
>
>
>
>template <class Model>
>struct usage_requirements
>{
> ~usage_requirements() { ((Model*)0)->~Model(); }
>};
># 42 "/usr/include/boost/concept/usage.hpp" 3 4
>}}
># 33 "/usr/include/boost/concept_check.hpp" 2 3 4
># 1 "/usr/include/boost/concept/detail/concept_def.hpp" 1 3 4
>
>
>
>
>
># 1 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/repetition/for.hpp" 1 3 4
># 19 "/usr/include/boost/preprocessor/repetition/for.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/repetition/for.hpp" 2 3 4
># 42 "/usr/include/boost/preprocessor/repetition/for.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/repetition/detail/for.hpp" 1 3 4
># 43 "/usr/include/boost/preprocessor/repetition/for.hpp" 2 3 4
># 19 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/seq/seq.hpp" 1 3 4
># 16 "/usr/include/boost/preprocessor/seq/seq.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/seq/elem.hpp" 1 3 4
># 17 "/usr/include/boost/preprocessor/seq/seq.hpp" 2 3 4
># 20 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/seq/size.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 2 3 4
># 7 "/usr/include/boost/concept/detail/concept_def.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/seq/enum.hpp" 1 3 4
># 8 "/usr/include/boost/concept/detail/concept_def.hpp" 2 3 4
># 34 "/usr/include/boost/concept_check.hpp" 2 3 4
>
>namespace boost
>{
>
>
>
>
>
> template <class Model>
> inline void function_requires(Model* = 0)
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Model)>::failed> boost_concept_check45 __attribute__((unused));
> }
> template <class T> inline void ignore_unused_variable_warning(T const&) {}
># 65 "/usr/include/boost/concept_check.hpp" 3 4
> template < typename T > struct Integer; template < typename T > struct IntegerConcept : Integer< T > { }; template < typename T > struct Integer
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Integer>)>::failed> boost_concept_check67 __attribute__((unused)); ~Integer()
> {
> x.error_type_must_be_an_integer_type();
> }
> private:
> T x;
> };
>
> template <> struct Integer<char> {};
> template <> struct Integer<signed char> {};
> template <> struct Integer<unsigned char> {};
> template <> struct Integer<short> {};
> template <> struct Integer<unsigned short> {};
> template <> struct Integer<int> {};
> template <> struct Integer<unsigned int> {};
> template <> struct Integer<long> {};
> template <> struct Integer<unsigned long> {};
>
> template <> struct Integer< ::boost::long_long_type> {};
> template <> struct Integer< ::boost::ulong_long_type> {};
>
>
>
>
>
> template < typename T > struct SignedInteger; template < typename T > struct SignedIntegerConcept : SignedInteger< T > { }; template < typename T > struct SignedInteger {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SignedInteger>)>::failed> boost_concept_check93 __attribute__((unused)); ~SignedInteger() {
> x.error_type_must_be_a_signed_integer_type();
> }
> private:
> T x;
> };
> template <> struct SignedInteger<signed char> { };
> template <> struct SignedInteger<short> {};
> template <> struct SignedInteger<int> {};
> template <> struct SignedInteger<long> {};
>
> template <> struct SignedInteger< ::boost::long_long_type> {};
>
>
>
>
> template < typename T > struct UnsignedInteger; template < typename T > struct UnsignedIntegerConcept : UnsignedInteger< T > { }; template < typename T > struct UnsignedInteger {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<UnsignedInteger>)>::failed> boost_concept_check110 __attribute__((unused)); ~UnsignedInteger() {
> x.error_type_must_be_an_unsigned_integer_type();
> }
> private:
> T x;
> };
>
> template <> struct UnsignedInteger<unsigned char> {};
> template <> struct UnsignedInteger<unsigned short> {};
> template <> struct UnsignedInteger<unsigned int> {};
> template <> struct UnsignedInteger<unsigned long> {};
>
> template <> struct UnsignedInteger< ::boost::ulong_long_type> {};
>
>
>
>
>
>
>
> template < typename TT > struct DefaultConstructible; template < typename TT > struct DefaultConstructibleConcept : DefaultConstructible< TT > { }; template < typename TT > struct DefaultConstructible
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<DefaultConstructible>)>::failed> boost_concept_check132 __attribute__((unused)); ~DefaultConstructible() {
> TT a;
> ignore_unused_variable_warning(a);
> }
> };
>
> template < typename TT > struct Assignable; template < typename TT > struct AssignableConcept : Assignable< TT > { }; template < typename TT > struct Assignable
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Assignable>)>::failed> boost_concept_check140 __attribute__((unused)); ~Assignable() {
>
> a = b;
>
> const_constraints(b);
> }
> private:
> void const_constraints(const TT& x) {
>
> a = x;
>
>
>
> }
> private:
> TT a;
> TT b;
> };
>
>
> template < typename TT > struct CopyConstructible; template < typename TT > struct CopyConstructibleConcept : CopyConstructible< TT > { }; template < typename TT > struct CopyConstructible
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<CopyConstructible>)>::failed> boost_concept_check162 __attribute__((unused)); ~CopyConstructible() {
> TT a(b);
> TT* ptr = &a;
> const_constraints(a);
> ignore_unused_variable_warning(ptr);
> }
> private:
> void const_constraints(const TT& a) {
> TT c(a);
> const TT* ptr = &a;
> ignore_unused_variable_warning(c);
> ignore_unused_variable_warning(ptr);
> }
> TT b;
> };
>
>
>
>
>
>
>
> template < typename TT > struct SGIAssignable; template < typename TT > struct SGIAssignableConcept : SGIAssignable< TT > { }; template < typename TT > struct SGIAssignable
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SGIAssignable>)>::failed> boost_concept_check186 __attribute__((unused)); ~SGIAssignable() {
> TT c(a);
>
> a = b;
>
> const_constraints(b);
> ignore_unused_variable_warning(c);
> }
> private:
> void const_constraints(const TT& x) {
> TT c(x);
>
> a = x;
>
> ignore_unused_variable_warning(c);
> }
> TT a;
> TT b;
> };
>
>
>
>
> template < typename X , typename Y > struct Convertible; template < typename X , typename Y > struct ConvertibleConcept : Convertible< X, Y > { }; template < typename X , typename Y > struct Convertible
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Convertible>)>::failed> boost_concept_check211 __attribute__((unused)); ~Convertible() {
> Y y = x;
> ignore_unused_variable_warning(y);
> }
> private:
> X x;
> };
># 228 "/usr/include/boost/concept_check.hpp" 3 4
> template <class TT>
> void require_boolean_expr(const TT& t) {
> bool x = t;
> ignore_unused_variable_warning(x);
> }
>
> template < typename TT > struct EqualityComparable; template < typename TT > struct EqualityComparableConcept : EqualityComparable< TT > { }; template < typename TT > struct EqualityComparable
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<EqualityComparable>)>::failed> boost_concept_check236 __attribute__((unused)); ~EqualityComparable() {
> require_boolean_expr(a == b);
> require_boolean_expr(a != b);
> }
> private:
> TT a, b;
> };
>
> template < typename TT > struct LessThanComparable; template < typename TT > struct LessThanComparableConcept : LessThanComparable< TT > { }; template < typename TT > struct LessThanComparable
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<LessThanComparable>)>::failed> boost_concept_check246 __attribute__((unused)); ~LessThanComparable() {
> require_boolean_expr(a < b);
> }
> private:
> TT a, b;
> };
>
>
> template < typename TT > struct Comparable; template < typename TT > struct ComparableConcept : Comparable< TT > { }; template < typename TT > struct Comparable
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Comparable>)>::failed> boost_concept_check256 __attribute__((unused)); ~Comparable() {
> require_boolean_expr(a < b);
> require_boolean_expr(a > b);
> require_boolean_expr(a <= b);
> require_boolean_expr(a >= b);
> }
> private:
> TT a, b;
> };
># 286 "/usr/include/boost/concept_check.hpp" 3 4
> template < typename First , typename Second > struct EqualOp; template < typename First , typename Second > struct EqualOpConcept : EqualOp< First, Second > { }; template < typename First , typename Second > struct EqualOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<EqualOp>)>::failed> boost_concept_check286 __attribute__((unused)); ~EqualOp() { (void)constraints_(); } private: bool constraints_() { return a == b; } First a; Second b; };
> template < typename First , typename Second > struct NotEqualOp; template < typename First , typename Second > struct NotEqualOpConcept : NotEqualOp< First, Second > { }; template < typename First , typename Second > struct NotEqualOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<NotEqualOp>)>::failed> boost_concept_check287 __attribute__((unused)); ~NotEqualOp() { (void)constraints_(); } private: bool constraints_() { return a != b; } First a; Second b; };
> template < typename First , typename Second > struct LessThanOp; template < typename First , typename Second > struct LessThanOpConcept : LessThanOp< First, Second > { }; template < typename First , typename Second > struct LessThanOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<LessThanOp>)>::failed> boost_concept_check288 __attribute__((unused)); ~LessThanOp() { (void)constraints_(); } private: bool constraints_() { return a < b; } First a; Second b; };
> template < typename First , typename Second > struct LessEqualOp; template < typename First , typename Second > struct LessEqualOpConcept : LessEqualOp< First, Second > { }; template < typename First , typename Second > struct LessEqualOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<LessEqualOp>)>::failed> boost_concept_check289 __attribute__((unused)); ~LessEqualOp() { (void)constraints_(); } private: bool constraints_() { return a <= b; } First a; Second b; };
> template < typename First , typename Second > struct GreaterThanOp; template < typename First , typename Second > struct GreaterThanOpConcept : GreaterThanOp< First, Second > { }; template < typename First , typename Second > struct GreaterThanOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<GreaterThanOp>)>::failed> boost_concept_check290 __attribute__((unused)); ~GreaterThanOp() { (void)constraints_(); } private: bool constraints_() { return a > b; } First a; Second b; };
> template < typename First , typename Second > struct GreaterEqualOp; template < typename First , typename Second > struct GreaterEqualOpConcept : GreaterEqualOp< First, Second > { }; template < typename First , typename Second > struct GreaterEqualOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<GreaterEqualOp>)>::failed> boost_concept_check291 __attribute__((unused)); ~GreaterEqualOp() { (void)constraints_(); } private: bool constraints_() { return a >= b; } First a; Second b; };
>
> template < typename Ret , typename First , typename Second > struct PlusOp; template < typename Ret , typename First , typename Second > struct PlusOpConcept : PlusOp< Ret, First, Second > { }; template < typename Ret , typename First , typename Second > struct PlusOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<PlusOp>)>::failed> boost_concept_check293 __attribute__((unused)); ~PlusOp() { (void)constraints_(); } private: Ret constraints_() { return a + b; } First a; Second b; };
> template < typename Ret , typename First , typename Second > struct TimesOp; template < typename Ret , typename First , typename Second > struct TimesOpConcept : TimesOp< Ret, First, Second > { }; template < typename Ret , typename First , typename Second > struct TimesOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<TimesOp>)>::failed> boost_concept_check294 __attribute__((unused)); ~TimesOp() { (void)constraints_(); } private: Ret constraints_() { return a * b; } First a; Second b; };
> template < typename Ret , typename First , typename Second > struct DivideOp; template < typename Ret , typename First , typename Second > struct DivideOpConcept : DivideOp< Ret, First, Second > { }; template < typename Ret , typename First , typename Second > struct DivideOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<DivideOp>)>::failed> boost_concept_check295 __attribute__((unused)); ~DivideOp() { (void)constraints_(); } private: Ret constraints_() { return a / b; } First a; Second b; };
> template < typename Ret , typename First , typename Second > struct SubtractOp; template < typename Ret , typename First , typename Second > struct SubtractOpConcept : SubtractOp< Ret, First, Second > { }; template < typename Ret , typename First , typename Second > struct SubtractOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SubtractOp>)>::failed> boost_concept_check296 __attribute__((unused)); ~SubtractOp() { (void)constraints_(); } private: Ret constraints_() { return a - b; } First a; Second b; };
> template < typename Ret , typename First , typename Second > struct ModOp; template < typename Ret , typename First , typename Second > struct ModOpConcept : ModOp< Ret, First, Second > { }; template < typename Ret , typename First , typename Second > struct ModOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ModOp>)>::failed> boost_concept_check297 __attribute__((unused)); ~ModOp() { (void)constraints_(); } private: Ret constraints_() { return a % b; } First a; Second b; };
>
>
>
>
> template < typename Func , typename Return > struct Generator; template < typename Func , typename Return > struct GeneratorConcept : Generator< Func, Return > { }; template < typename Func , typename Return > struct Generator
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Generator>)>::failed> boost_concept_check304 __attribute__((unused)); ~Generator() { test(is_void<Return>()); }
>
> private:
> void test(boost::mpl::false_)
> {
>
> const Return& r = f();
> ignore_unused_variable_warning(r);
> }
>
> void test(boost::mpl::true_)
> {
> f();
> }
>
> Func f;
> };
>
> template < typename Func , typename Return , typename Arg > struct UnaryFunction; template < typename Func , typename Return , typename Arg > struct UnaryFunctionConcept : UnaryFunction< Func, Return, Arg > { }; template < typename Func , typename Return , typename Arg > struct UnaryFunction
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<UnaryFunction>)>::failed> boost_concept_check324 __attribute__((unused)); ~UnaryFunction() { test(is_void<Return>()); }
>
> private:
> void test(boost::mpl::false_)
> {
> f(arg);
> Return r = f(arg);
> ignore_unused_variable_warning(r);
> }
>
> void test(boost::mpl::true_)
> {
> f(arg);
> }
>
>
>
>
>
>
>
> UnaryFunction();
>
>
> Func f;
> Arg arg;
> };
>
> template < typename Func , typename Return , typename First , typename Second > struct BinaryFunction; template < typename Func , typename Return , typename First , typename Second > struct BinaryFunctionConcept : BinaryFunction< Func, Return, First, Second > { }; template < typename Func , typename Return , typename First , typename Second > struct BinaryFunction
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BinaryFunction>)>::failed> boost_concept_check354 __attribute__((unused)); ~BinaryFunction() { test(is_void<Return>()); }
> private:
> void test(boost::mpl::false_)
> {
> f(first,second);
> Return r = f(first, second);
> (void)r;
> }
>
> void test(boost::mpl::true_)
> {
> f(first,second);
> }
>
>
>
>
>
>
>
> BinaryFunction();
>
>
> Func f;
> First first;
> Second second;
> };
>
> template < typename Func , typename Arg > struct UnaryPredicate; template < typename Func , typename Arg > struct UnaryPredicateConcept : UnaryPredicate< Func, Arg > { }; template < typename Func , typename Arg > struct UnaryPredicate
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<UnaryPredicate>)>::failed> boost_concept_check384 __attribute__((unused)); ~UnaryPredicate() {
> require_boolean_expr(f(arg));
> }
> private:
>
>
>
>
>
>
> UnaryPredicate();
>
>
> Func f;
> Arg arg;
> };
>
> template < typename Func , typename First , typename Second > struct BinaryPredicate; template < typename Func , typename First , typename Second > struct BinaryPredicateConcept : BinaryPredicate< Func, First, Second > { }; template < typename Func , typename First , typename Second > struct BinaryPredicate
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BinaryPredicate>)>::failed> boost_concept_check403 __attribute__((unused)); ~BinaryPredicate() {
> require_boolean_expr(f(a, b));
> }
> private:
>
>
>
>
>
>
> BinaryPredicate();
>
> Func f;
> First a;
> Second b;
> };
>
>
> template < typename Func , typename First , typename Second > struct Const_BinaryPredicate; template < typename Func , typename First , typename Second > struct Const_BinaryPredicateConcept : Const_BinaryPredicate< Func, First, Second > { }; template < typename Func , typename First , typename Second > struct Const_BinaryPredicate
> : BinaryPredicate<Func, First, Second>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Const_BinaryPredicate>)>::failed> boost_concept_check424 __attribute__((unused)); ~Const_BinaryPredicate() {
> const_constraints(f);
> }
> private:
> void const_constraints(const Func& fun) {
>
> require_boolean_expr(fun(a, b));
> }
>
>
>
>
>
>
> Const_BinaryPredicate();
>
>
> Func f;
> First a;
> Second b;
> };
>
> template < typename Func , typename Return > struct AdaptableGenerator; template < typename Func , typename Return > struct AdaptableGeneratorConcept : AdaptableGenerator< Func, Return > { }; template < typename Func , typename Return > struct AdaptableGenerator
> : Generator<Func, typename Func::result_type>
> {
> typedef typename Func::result_type result_type;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<AdaptableGenerator>)>::failed> boost_concept_check451 __attribute__((unused)); ~AdaptableGenerator()
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<result_type, Return>)>::failed> boost_concept_check453 __attribute__((unused));
> }
> };
>
> template < typename Func , typename Return , typename Arg > struct AdaptableUnaryFunction; template < typename Func , typename Return , typename Arg > struct AdaptableUnaryFunctionConcept : AdaptableUnaryFunction< Func, Return, Arg > { }; template < typename Func , typename Return , typename Arg > struct AdaptableUnaryFunction
> : UnaryFunction<Func, typename Func::result_type, typename Func::argument_type>
> {
> typedef typename Func::argument_type argument_type;
> typedef typename Func::result_type result_type;
>
> ~AdaptableUnaryFunction()
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<result_type, Return>)>::failed> boost_concept_check465 __attribute__((unused));
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<Arg, argument_type>)>::failed> boost_concept_check466 __attribute__((unused));
> }
> };
>
> template < typename Func , typename Return , typename First , typename Second > struct AdaptableBinaryFunction; template < typename Func , typename Return , typename First , typename Second > struct AdaptableBinaryFunctionConcept : AdaptableBinaryFunction< Func, Return, First, Second > { }; template < typename Func , typename Return , typename First , typename Second > struct AdaptableBinaryFunction
> : BinaryFunction<
> Func
> , typename Func::result_type
> , typename Func::first_argument_type
> , typename Func::second_argument_type
> >
> {
> typedef typename Func::first_argument_type first_argument_type;
> typedef typename Func::second_argument_type second_argument_type;
> typedef typename Func::result_type result_type;
>
> ~AdaptableBinaryFunction()
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<result_type, Return>)>::failed> boost_concept_check484 __attribute__((unused));
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<First, first_argument_type>)>::failed> boost_concept_check485 __attribute__((unused));
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<Second, second_argument_type>)>::failed> boost_concept_check486 __attribute__((unused));
> }
> };
>
> template < typename Func , typename Arg > struct AdaptablePredicate; template < typename Func , typename Arg > struct AdaptablePredicateConcept : AdaptablePredicate< Func, Arg > { }; template < typename Func , typename Arg > struct AdaptablePredicate
> : UnaryPredicate<Func, Arg>
> , AdaptableUnaryFunction<Func, bool, Arg>
> {
> };
>
> template < typename Func , typename First , typename Second > struct AdaptableBinaryPredicate; template < typename Func , typename First , typename Second > struct AdaptableBinaryPredicateConcept : AdaptableBinaryPredicate< Func, First, Second > { }; template < typename Func , typename First , typename Second > struct AdaptableBinaryPredicate
> : BinaryPredicate<Func, First, Second>
> , AdaptableBinaryFunction<Func, bool, First, Second>
> {
> };
>
>
>
>
> template < typename TT > struct InputIterator; template < typename TT > struct InputIteratorConcept : InputIterator< TT > { }; template < typename TT > struct InputIterator
> : Assignable<TT>
> , EqualityComparable<TT>
> {
> typedef typename boost::detail::iterator_traits<TT>::value_type value_type;
> typedef typename boost::detail::iterator_traits<TT>::difference_type difference_type;
> typedef typename boost::detail::iterator_traits<TT>::reference reference;
> typedef typename boost::detail::iterator_traits<TT>::pointer pointer;
> typedef typename boost::detail::iterator_traits<TT>::iterator_category iterator_category;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<InputIterator>)>::failed> boost_concept_check515 __attribute__((unused)); ~InputIterator()
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(SignedInteger<difference_type>)>::failed> boost_concept_check517 __attribute__((unused));
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<iterator_category, std::input_iterator_tag>)>::failed> boost_concept_check518 __attribute__((unused));
>
> TT j(i);
> (void)*i;
> ++j;
> i++;
> }
> private:
> TT i;
> };
>
> template < typename TT , typename ValueT > struct OutputIterator; template < typename TT , typename ValueT > struct OutputIteratorConcept : OutputIterator< TT, ValueT > { }; template < typename TT , typename ValueT > struct OutputIterator
> : Assignable<TT>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<OutputIterator>)>::failed> boost_concept_check532 __attribute__((unused)); ~OutputIterator() {
>
> ++i;
> i++;
> *i++ = t;
> }
> private:
> TT i, j;
> ValueT t;
> };
>
> template < typename TT > struct ForwardIterator; template < typename TT > struct ForwardIteratorConcept : ForwardIterator< TT > { }; template < typename TT > struct ForwardIterator
> : InputIterator<TT>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ForwardIterator>)>::failed> boost_concept_check546 __attribute__((unused)); ~ForwardIterator()
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible< typename ForwardIterator::iterator_category , std::forward_iterator_tag >)>::failed> boost_concept_check551 __attribute__((unused))
>
>
> ;
>
> typename InputIterator<TT>::reference r = *i;
> ignore_unused_variable_warning(r);
> }
>
> private:
> TT i;
> };
>
> template < typename TT > struct Mutable_ForwardIterator; template < typename TT > struct Mutable_ForwardIteratorConcept : Mutable_ForwardIterator< TT > { }; template < typename TT > struct Mutable_ForwardIterator
> : ForwardIterator<TT>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_ForwardIterator>)>::failed> boost_concept_check564 __attribute__((unused)); ~Mutable_ForwardIterator() {
> *i++ = *i;
> }
> private:
> TT i;
> };
>
> template < typename TT > struct BidirectionalIterator; template < typename TT > struct BidirectionalIteratorConcept : BidirectionalIterator< TT > { }; template < typename TT > struct BidirectionalIterator
> : ForwardIterator<TT>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BidirectionalIterator>)>::failed> boost_concept_check574 __attribute__((unused)); ~BidirectionalIterator()
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible< typename BidirectionalIterator::iterator_category , std::bidirectional_iterator_tag >)>::failed> boost_concept_check579 __attribute__((unused))
>
>
> ;
>
> --i;
> i--;
> }
> private:
> TT i;
> };
>
> template < typename TT > struct Mutable_BidirectionalIterator; template < typename TT > struct Mutable_BidirectionalIteratorConcept : Mutable_BidirectionalIterator< TT > { }; template < typename TT > struct Mutable_BidirectionalIterator
> : BidirectionalIterator<TT>
> , Mutable_ForwardIterator<TT>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_BidirectionalIterator>)>::failed> boost_concept_check592 __attribute__((unused)); ~Mutable_BidirectionalIterator()
> {
> *i-- = *i;
> }
> private:
> TT i;
> };
>
> template < typename TT > struct RandomAccessIterator; template < typename TT > struct RandomAccessIteratorConcept : RandomAccessIterator< TT > { }; template < typename TT > struct RandomAccessIterator
> : BidirectionalIterator<TT>
> , Comparable<TT>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<RandomAccessIterator>)>::failed> boost_concept_check604 __attribute__((unused)); ~RandomAccessIterator()
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible< typename BidirectionalIterator<TT>::iterator_category , std::random_access_iterator_tag >)>::failed> boost_concept_check609 __attribute__((unused))
>
>
> ;
>
> i += n;
> i = i + n; i = n + i;
> i -= n;
> i = i - n;
> n = i - j;
> (void)i[n];
> }
>
> private:
> TT a, b;
> TT i, j;
> typename boost::detail::iterator_traits<TT>::difference_type n;
> };
>
> template < typename TT > struct Mutable_RandomAccessIterator; template < typename TT > struct Mutable_RandomAccessIteratorConcept : Mutable_RandomAccessIterator< TT > { }; template < typename TT > struct Mutable_RandomAccessIterator
> : RandomAccessIterator<TT>
> , Mutable_BidirectionalIterator<TT>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_RandomAccessIterator>)>::failed> boost_concept_check629 __attribute__((unused)); ~Mutable_RandomAccessIterator()
> {
> i[n] = *i;
> }
> private:
> TT i;
> typename boost::detail::iterator_traits<TT>::difference_type n;
> };
>
>
>
>
> template < typename C > struct Container; template < typename C > struct ContainerConcept : Container< C > { }; template < typename C > struct Container
> : Assignable<C>
> {
> typedef typename C::value_type value_type;
> typedef typename C::difference_type difference_type;
> typedef typename C::size_type size_type;
> typedef typename C::const_reference const_reference;
> typedef typename C::const_pointer const_pointer;
> typedef typename C::const_iterator const_iterator;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Container>)>::failed> boost_concept_check651 __attribute__((unused)); ~Container()
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(InputIterator<const_iterator>)>::failed> boost_concept_check653 __attribute__((unused));
> const_constraints(c);
> }
>
> private:
> void const_constraints(const C& cc) {
> i = cc.begin();
> i = cc.end();
> n = cc.size();
> n = cc.max_size();
> b = cc.empty();
> }
> C c;
> bool b;
> const_iterator i;
> size_type n;
> };
>
> template < typename C > struct Mutable_Container; template < typename C > struct Mutable_ContainerConcept : Mutable_Container< C > { }; template < typename C > struct Mutable_Container
> : Container<C>
> {
> typedef typename C::reference reference;
> typedef typename C::iterator iterator;
> typedef typename C::pointer pointer;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_Container>)>::failed> boost_concept_check678 __attribute__((unused)); ~Mutable_Container()
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Assignable<typename Mutable_Container::value_type>)>::failed> boost_concept_check681 __attribute__((unused))
> ;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(InputIterator<iterator>)>::failed> boost_concept_check683 __attribute__((unused));
>
> i = c.begin();
> i = c.end();
> c.swap(c2);
> }
>
> private:
> iterator i;
> C c, c2;
> };
>
> template < typename C > struct ForwardContainer; template < typename C > struct ForwardContainerConcept : ForwardContainer< C > { }; template < typename C > struct ForwardContainer
> : Container<C>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ForwardContainer>)>::failed> boost_concept_check698 __attribute__((unused)); ~ForwardContainer()
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( ForwardIterator< typename ForwardContainer::const_iterator >)>::failed> boost_concept_check703 __attribute__((unused))
>
>
> ;
> }
> };
>
> template < typename C > struct Mutable_ForwardContainer; template < typename C > struct Mutable_ForwardContainerConcept : Mutable_ForwardContainer< C > { }; template < typename C > struct Mutable_ForwardContainer
> : ForwardContainer<C>
> , Mutable_Container<C>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_ForwardContainer>)>::failed> boost_concept_check711 __attribute__((unused)); ~Mutable_ForwardContainer()
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Mutable_ForwardIterator< typename Mutable_ForwardContainer::iterator >)>::failed> boost_concept_check716 __attribute__((unused))
>
>
> ;
> }
> };
>
> template < typename C > struct ReversibleContainer; template < typename C > struct ReversibleContainerConcept : ReversibleContainer< C > { }; template < typename C > struct ReversibleContainer
> : ForwardContainer<C>
> {
> typedef typename
> C::const_reverse_iterator
> const_reverse_iterator;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ReversibleContainer>)>::failed> boost_concept_check727 __attribute__((unused)); ~ReversibleContainer()
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( BidirectionalIterator< typename ReversibleContainer::const_iterator>)>::failed> boost_concept_check731 __attribute__((unused))
>
> ;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(BidirectionalIterator<const_reverse_iterator>)>::failed> boost_concept_check733 __attribute__((unused));
>
> const_constraints(c);
> }
> private:
> void const_constraints(const C& cc)
> {
> const_reverse_iterator i = cc.rbegin();
> i = cc.rend();
> }
> C c;
> };
>
> template < typename C > struct Mutable_ReversibleContainer; template < typename C > struct Mutable_ReversibleContainerConcept : Mutable_ReversibleContainer< C > { }; template < typename C > struct Mutable_ReversibleContainer
> : Mutable_ForwardContainer<C>
> , ReversibleContainer<C>
> {
> typedef typename C::reverse_iterator reverse_iterator;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_ReversibleContainer>)>::failed> boost_concept_check752 __attribute__((unused)); ~Mutable_ReversibleContainer()
> {
> typedef typename Mutable_ForwardContainer<C>::iterator iterator;
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Mutable_BidirectionalIterator<iterator>)>::failed> boost_concept_check755 __attribute__((unused));
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Mutable_BidirectionalIterator<reverse_iterator>)>::failed> boost_concept_check756 __attribute__((unused));
>
> reverse_iterator i = c.rbegin();
> i = c.rend();
> }
> private:
> C c;
> };
>
> template < typename C > struct RandomAccessContainer; template < typename C > struct RandomAccessContainerConcept : RandomAccessContainer< C > { }; template < typename C > struct RandomAccessContainer
> : ReversibleContainer<C>
> {
> typedef typename C::size_type size_type;
> typedef typename C::const_reference const_reference;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<RandomAccessContainer>)>::failed> boost_concept_check771 __attribute__((unused)); ~RandomAccessContainer()
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( RandomAccessIterator< typename RandomAccessContainer::const_iterator >)>::failed> boost_concept_check776 __attribute__((unused))
>
>
> ;
>
> const_constraints(c);
> }
> private:
> void const_constraints(const C& cc)
> {
> const_reference r = cc[n];
> ignore_unused_variable_warning(r);
> }
>
> C c;
> size_type n;
> };
>
> template < typename C > struct Mutable_RandomAccessContainer; template < typename C > struct Mutable_RandomAccessContainerConcept : Mutable_RandomAccessContainer< C > { }; template < typename C > struct Mutable_RandomAccessContainer
> : Mutable_ReversibleContainer<C>
> , RandomAccessContainer<C>
> {
> private:
> typedef Mutable_RandomAccessContainer self;
> public:
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_RandomAccessContainer>)>::failed> boost_concept_check798 __attribute__((unused)); ~Mutable_RandomAccessContainer()
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Mutable_RandomAccessIterator<typename self::iterator>)>::failed> boost_concept_check800 __attribute__((unused));
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Mutable_RandomAccessIterator<typename self::reverse_iterator>)>::failed> boost_concept_check801 __attribute__((unused));
>
> typename self::reference r = c[i];
> ignore_unused_variable_warning(r);
> }
>
> private:
> typename Mutable_ReversibleContainer<C>::size_type i;
> C c;
> };
>
>
> template < typename S > struct Sequence; template < typename S > struct SequenceConcept : Sequence< S > { }; template < typename S > struct Sequence
> : Mutable_ForwardContainer<S>
>
>
>
> , DefaultConstructible<S>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Sequence>)>::failed> boost_concept_check820 __attribute__((unused)); ~Sequence()
> {
> S
> c(n),
> c2(n, t),
> c3(first, last);
>
> c.insert(p, t);
> c.insert(p, n, t);
> c.insert(p, first, last);
>
> c.erase(p);
> c.erase(p, q);
>
> typename Sequence::reference r = c.front();
>
> ignore_unused_variable_warning(c);
> ignore_unused_variable_warning(c2);
> ignore_unused_variable_warning(c3);
> ignore_unused_variable_warning(r);
> const_constraints(c);
> }
> private:
> void const_constraints(const S& c) {
> typename Sequence::const_reference r = c.front();
> ignore_unused_variable_warning(r);
> }
>
> typename S::value_type t;
> typename S::size_type n;
> typename S::value_type* first, *last;
> typename S::iterator p, q;
> };
>
> template < typename S > struct FrontInsertionSequence; template < typename S > struct FrontInsertionSequenceConcept : FrontInsertionSequence< S > { }; template < typename S > struct FrontInsertionSequence
> : Sequence<S>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<FrontInsertionSequence>)>::failed> boost_concept_check857 __attribute__((unused)); ~FrontInsertionSequence()
> {
> c.push_front(t);
> c.pop_front();
> }
> private:
> S c;
> typename S::value_type t;
> };
>
> template < typename S > struct BackInsertionSequence; template < typename S > struct BackInsertionSequenceConcept : BackInsertionSequence< S > { }; template < typename S > struct BackInsertionSequence
> : Sequence<S>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BackInsertionSequence>)>::failed> boost_concept_check870 __attribute__((unused)); ~BackInsertionSequence()
> {
> c.push_back(t);
> c.pop_back();
> typename BackInsertionSequence::reference r = c.back();
> ignore_unused_variable_warning(r);
> const_constraints(c);
> }
> private:
> void const_constraints(const S& cc) {
> typename BackInsertionSequence::const_reference
> r = cc.back();
> ignore_unused_variable_warning(r);
> };
> S c;
> typename S::value_type t;
> };
>
> template < typename C > struct AssociativeContainer; template < typename C > struct AssociativeContainerConcept : AssociativeContainer< C > { }; template < typename C > struct AssociativeContainer
> : ForwardContainer<C>
> , DefaultConstructible<C>
> {
> typedef typename C::key_type key_type;
> typedef typename C::key_compare key_compare;
> typedef typename C::value_compare value_compare;
> typedef typename C::iterator iterator;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<AssociativeContainer>)>::failed> boost_concept_check897 __attribute__((unused)); ~AssociativeContainer()
> {
> i = c.find(k);
> r = c.equal_range(k);
> c.erase(k);
> c.erase(i);
> c.erase(r.first, r.second);
> const_constraints(c);
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(BinaryPredicate<key_compare,key_type,key_type>)>::failed> boost_concept_check905 __attribute__((unused));
>
> typedef typename AssociativeContainer::value_type value_type_;
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(BinaryPredicate<value_compare,value_type_,value_type_>)>::failed> boost_concept_check908 __attribute__((unused));
> }
>
>
> typedef typename C::const_iterator const_iterator;
> private:
> void const_constraints(const C& cc)
> {
> ci = cc.find(k);
> n = cc.count(k);
> cr = cc.equal_range(k);
> }
>
> C c;
> iterator i;
> std::pair<iterator,iterator> r;
> const_iterator ci;
> std::pair<const_iterator,const_iterator> cr;
> typename C::key_type k;
> typename C::size_type n;
> };
>
> template < typename C > struct UniqueAssociativeContainer; template < typename C > struct UniqueAssociativeContainerConcept : UniqueAssociativeContainer< C > { }; template < typename C > struct UniqueAssociativeContainer
> : AssociativeContainer<C>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<UniqueAssociativeContainer>)>::failed> boost_concept_check933 __attribute__((unused)); ~UniqueAssociativeContainer()
> {
> C c(first, last);
>
> pos_flag = c.insert(t);
> c.insert(first, last);
>
> ignore_unused_variable_warning(c);
> }
> private:
> std::pair<typename C::iterator, bool> pos_flag;
> typename C::value_type t;
> typename C::value_type* first, *last;
> };
>
> template < typename C > struct MultipleAssociativeContainer; template < typename C > struct MultipleAssociativeContainerConcept : MultipleAssociativeContainer< C > { }; template < typename C > struct MultipleAssociativeContainer
> : AssociativeContainer<C>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<MultipleAssociativeContainer>)>::failed> boost_concept_check951 __attribute__((unused)); ~MultipleAssociativeContainer()
> {
> C c(first, last);
>
> pos = c.insert(t);
> c.insert(first, last);
>
> ignore_unused_variable_warning(c);
> ignore_unused_variable_warning(pos);
> }
> private:
> typename C::iterator pos;
> typename C::value_type t;
> typename C::value_type* first, *last;
> };
>
> template < typename C > struct SimpleAssociativeContainer; template < typename C > struct SimpleAssociativeContainerConcept : SimpleAssociativeContainer< C > { }; template < typename C > struct SimpleAssociativeContainer
> : AssociativeContainer<C>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SimpleAssociativeContainer>)>::failed> boost_concept_check970 __attribute__((unused)); ~SimpleAssociativeContainer()
> {
> typedef typename C::key_type key_type;
> typedef typename C::value_type value_type;
> enum { mpl_assertion_in_line_974 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (boost::is_same<key_type,value_type>))0, 1 ) ) ) };
> }
> };
>
> template < typename C > struct PairAssociativeContainer; template < typename C > struct PairAssociativeContainerConcept : PairAssociativeContainer< C > { }; template < typename C > struct PairAssociativeContainer
> : AssociativeContainer<C>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<PairAssociativeContainer>)>::failed> boost_concept_check981 __attribute__((unused)); ~PairAssociativeContainer()
> {
> typedef typename C::key_type key_type;
> typedef typename C::value_type value_type;
> typedef typename C::mapped_type mapped_type;
> typedef std::pair<const key_type, mapped_type> required_value_type;
> enum { mpl_assertion_in_line_987 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (boost::is_same<value_type,required_value_type>))0, 1 ) ) ) };
> }
> };
>
> template < typename C > struct SortedAssociativeContainer; template < typename C > struct SortedAssociativeContainerConcept : SortedAssociativeContainer< C > { }; template < typename C > struct SortedAssociativeContainer
> : AssociativeContainer<C>
> , ReversibleContainer<C>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SortedAssociativeContainer>)>::failed> boost_concept_check995 __attribute__((unused)); ~SortedAssociativeContainer()
> {
> C
> c(kc),
> c2(first, last),
> c3(first, last, kc);
>
> p = c.upper_bound(k);
> p = c.lower_bound(k);
> r = c.equal_range(k);
>
> c.insert(p, t);
>
> ignore_unused_variable_warning(c);
> ignore_unused_variable_warning(c2);
> ignore_unused_variable_warning(c3);
> const_constraints(c);
> }
>
> void const_constraints(const C& c)
> {
> kc = c.key_comp();
> vc = c.value_comp();
>
> cp = c.upper_bound(k);
> cp = c.lower_bound(k);
> cr = c.equal_range(k);
> }
>
> private:
> typename C::key_compare kc;
> typename C::value_compare vc;
> typename C::value_type t;
> typename C::key_type k;
> typedef typename C::iterator iterator;
> typedef typename C::const_iterator const_iterator;
>
> typedef SortedAssociativeContainer self;
> iterator p;
> const_iterator cp;
> std::pair<typename self::iterator,typename self::iterator> r;
> std::pair<typename self::const_iterator,typename self::const_iterator> cr;
> typename C::value_type* first, *last;
> };
>
>
>
> template < typename C > struct Collection; template < typename C > struct CollectionConcept : Collection< C > { }; template < typename C > struct Collection
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Collection>)>::failed> boost_concept_check1044 __attribute__((unused)); ~Collection()
> {
> boost::function_requires<boost::InputIteratorConcept<iterator> >();
> boost::function_requires<boost::InputIteratorConcept<const_iterator> >();
> boost::function_requires<boost::CopyConstructibleConcept<value_type> >();
> const_constraints(c);
> i = c.begin();
> i = c.end();
> c.swap(c);
> }
>
> void const_constraints(const C& cc) {
> ci = cc.begin();
> ci = cc.end();
> n = cc.size();
> b = cc.empty();
> }
>
> private:
> typedef typename C::value_type value_type;
> typedef typename C::iterator iterator;
> typedef typename C::const_iterator const_iterator;
> typedef typename C::reference reference;
> typedef typename C::const_reference const_reference;
>
> typedef typename C::difference_type difference_type;
> typedef typename C::size_type size_type;
>
> C c;
> bool b;
> iterator i;
> const_iterator ci;
> size_type n;
> };
>}
>
># 1 "/usr/include/boost/concept/detail/concept_undef.hpp" 1 3 4
># 1081 "/usr/include/boost/concept_check.hpp" 2 3 4
># 18 "/usr/include/boost/circular_buffer/base.hpp" 2 3 4
># 1 "/usr/include/boost/limits.hpp" 1 3 4
># 19 "/usr/include/boost/limits.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/limits" 1 3 4
># 40 "/usr/include/c++/4.8.2/limits" 3 4
> 
># 41 "/usr/include/c++/4.8.2/limits" 3
># 147 "/usr/include/c++/4.8.2/limits" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> enum float_round_style
> {
> round_indeterminate = -1,
> round_toward_zero = 0,
> round_to_nearest = 1,
> round_toward_infinity = 2,
> round_toward_neg_infinity = 3
> };
>
>
>
>
>
>
>
> enum float_denorm_style
> {
>
> denorm_indeterminate = -1,
>
> denorm_absent = 0,
>
> denorm_present = 1
> };
># 191 "/usr/include/c++/4.8.2/limits" 3
> struct __numeric_limits_base
> {
>
>
> static constexpr bool is_specialized = false;
>
>
>
>
> static constexpr int digits = 0;
>
>
> static constexpr int digits10 = 0;
>
>
>
>
> static constexpr int max_digits10 = 0;
>
>
>
> static constexpr bool is_signed = false;
>
>
> static constexpr bool is_integer = false;
>
>
>
>
> static constexpr bool is_exact = false;
>
>
>
> static constexpr int radix = 0;
>
>
>
> static constexpr int min_exponent = 0;
>
>
>
> static constexpr int min_exponent10 = 0;
>
>
>
>
> static constexpr int max_exponent = 0;
>
>
>
> static constexpr int max_exponent10 = 0;
>
>
> static constexpr bool has_infinity = false;
>
>
>
> static constexpr bool has_quiet_NaN = false;
>
>
>
> static constexpr bool has_signaling_NaN = false;
>
>
> static constexpr float_denorm_style has_denorm = denorm_absent;
>
>
>
> static constexpr bool has_denorm_loss = false;
>
>
>
> static constexpr bool is_iec559 = false;
>
>
>
>
> static constexpr bool is_bounded = false;
># 277 "/usr/include/c++/4.8.2/limits" 3
> static constexpr bool is_modulo = false;
>
>
> static constexpr bool traps = false;
>
>
> static constexpr bool tinyness_before = false;
>
>
>
>
> static constexpr float_round_style round_style =
> round_toward_zero;
> };
># 303 "/usr/include/c++/4.8.2/limits" 3
> template<typename _Tp>
> struct numeric_limits : public __numeric_limits_base
> {
>
>
> static constexpr _Tp
> min() noexcept { return _Tp(); }
>
>
> static constexpr _Tp
> max() noexcept { return _Tp(); }
>
>
>
>
> static constexpr _Tp
> lowest() noexcept { return _Tp(); }
>
>
>
>
> static constexpr _Tp
> epsilon() noexcept { return _Tp(); }
>
>
> static constexpr _Tp
> round_error() noexcept { return _Tp(); }
>
>
> static constexpr _Tp
> infinity() noexcept { return _Tp(); }
>
>
>
> static constexpr _Tp
> quiet_NaN() noexcept { return _Tp(); }
>
>
>
> static constexpr _Tp
> signaling_NaN() noexcept { return _Tp(); }
>
>
>
>
> static constexpr _Tp
> denorm_min() noexcept { return _Tp(); }
> };
>
>
> template<typename _Tp>
> struct numeric_limits<const _Tp>
> : public numeric_limits<_Tp> { };
>
> template<typename _Tp>
> struct numeric_limits<volatile _Tp>
> : public numeric_limits<_Tp> { };
>
> template<typename _Tp>
> struct numeric_limits<const volatile _Tp>
> : public numeric_limits<_Tp> { };
>
>
>
>
>
>
> template<>
> struct numeric_limits<bool>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr bool
> min() noexcept { return false; }
>
> static constexpr bool
> max() noexcept { return true; }
>
>
> static constexpr bool
> lowest() noexcept { return min(); }
>
> static constexpr int digits = 1;
> static constexpr int digits10 = 0;
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr bool
> epsilon() noexcept { return false; }
>
> static constexpr bool
> round_error() noexcept { return false; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr bool
> infinity() noexcept { return false; }
>
> static constexpr bool
> quiet_NaN() noexcept { return false; }
>
> static constexpr bool
> signaling_NaN() noexcept { return false; }
>
> static constexpr bool
> denorm_min() noexcept { return false; }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
>
>
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<char>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr char
> min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }
>
> static constexpr char
> max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }
>
>
> static constexpr char
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
> static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = ((char)(-1) < 0);
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr char
> epsilon() noexcept { return 0; }
>
> static constexpr char
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr
> char infinity() noexcept { return char(); }
>
> static constexpr char
> quiet_NaN() noexcept { return char(); }
>
> static constexpr char
> signaling_NaN() noexcept { return char(); }
>
> static constexpr char
> denorm_min() noexcept { return static_cast<char>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = !is_signed;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<signed char>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr signed char
> min() noexcept { return -127 - 1; }
>
> static constexpr signed char
> max() noexcept { return 127; }
>
>
> static constexpr signed char
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr signed char
> epsilon() noexcept { return 0; }
>
> static constexpr signed char
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr signed char
> infinity() noexcept { return static_cast<signed char>(0); }
>
> static constexpr signed char
> quiet_NaN() noexcept { return static_cast<signed char>(0); }
>
> static constexpr signed char
> signaling_NaN() noexcept
> { return static_cast<signed char>(0); }
>
> static constexpr signed char
> denorm_min() noexcept
> { return static_cast<signed char>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned char>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr unsigned char
> min() noexcept { return 0; }
>
> static constexpr unsigned char
> max() noexcept { return 127 * 2U + 1; }
>
>
> static constexpr unsigned char
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr unsigned char
> epsilon() noexcept { return 0; }
>
> static constexpr unsigned char
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr unsigned char
> infinity() noexcept
> { return static_cast<unsigned char>(0); }
>
> static constexpr unsigned char
> quiet_NaN() noexcept
> { return static_cast<unsigned char>(0); }
>
> static constexpr unsigned char
> signaling_NaN() noexcept
> { return static_cast<unsigned char>(0); }
>
> static constexpr unsigned char
> denorm_min() noexcept
> { return static_cast<unsigned char>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<wchar_t>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr wchar_t
> min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }
>
> static constexpr wchar_t
> max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }
>
>
> static constexpr wchar_t
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = ((wchar_t)(-1) < 0);
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr wchar_t
> epsilon() noexcept { return 0; }
>
> static constexpr wchar_t
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr wchar_t
> infinity() noexcept { return wchar_t(); }
>
> static constexpr wchar_t
> quiet_NaN() noexcept { return wchar_t(); }
>
> static constexpr wchar_t
> signaling_NaN() noexcept { return wchar_t(); }
>
> static constexpr wchar_t
> denorm_min() noexcept { return wchar_t(); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = !is_signed;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
>
> template<>
> struct numeric_limits<char16_t>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr char16_t
> min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); }
>
> static constexpr char16_t
> max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); }
>
> static constexpr char16_t
> lowest() noexcept { return min(); }
>
> static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
> static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
> static constexpr int max_digits10 = 0;
> static constexpr bool is_signed = ((char16_t)(-1) < 0);
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr char16_t
> epsilon() noexcept { return 0; }
>
> static constexpr char16_t
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr char16_t
> infinity() noexcept { return char16_t(); }
>
> static constexpr char16_t
> quiet_NaN() noexcept { return char16_t(); }
>
> static constexpr char16_t
> signaling_NaN() noexcept { return char16_t(); }
>
> static constexpr char16_t
> denorm_min() noexcept { return char16_t(); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = !is_signed;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<char32_t>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr char32_t
> min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); }
>
> static constexpr char32_t
> max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); }
>
> static constexpr char32_t
> lowest() noexcept { return min(); }
>
> static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
> static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
> static constexpr int max_digits10 = 0;
> static constexpr bool is_signed = ((char32_t)(-1) < 0);
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr char32_t
> epsilon() noexcept { return 0; }
>
> static constexpr char32_t
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr char32_t
> infinity() noexcept { return char32_t(); }
>
> static constexpr char32_t
> quiet_NaN() noexcept { return char32_t(); }
>
> static constexpr char32_t
> signaling_NaN() noexcept { return char32_t(); }
>
> static constexpr char32_t
> denorm_min() noexcept { return char32_t(); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = !is_signed;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style = round_toward_zero;
> };
>
>
>
> template<>
> struct numeric_limits<short>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr short
> min() noexcept { return -32767 - 1; }
>
> static constexpr short
> max() noexcept { return 32767; }
>
>
> static constexpr short
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
> static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr short
> epsilon() noexcept { return 0; }
>
> static constexpr short
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr short
> infinity() noexcept { return short(); }
>
> static constexpr short
> quiet_NaN() noexcept { return short(); }
>
> static constexpr short
> signaling_NaN() noexcept { return short(); }
>
> static constexpr short
> denorm_min() noexcept { return short(); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned short>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr unsigned short
> min() noexcept { return 0; }
>
> static constexpr unsigned short
> max() noexcept { return 32767 * 2U + 1; }
>
>
> static constexpr unsigned short
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr unsigned short
> epsilon() noexcept { return 0; }
>
> static constexpr unsigned short
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr unsigned short
> infinity() noexcept
> { return static_cast<unsigned short>(0); }
>
> static constexpr unsigned short
> quiet_NaN() noexcept
> { return static_cast<unsigned short>(0); }
>
> static constexpr unsigned short
> signaling_NaN() noexcept
> { return static_cast<unsigned short>(0); }
>
> static constexpr unsigned short
> denorm_min() noexcept
> { return static_cast<unsigned short>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<int>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr int
> min() noexcept { return -2147483647 - 1; }
>
> static constexpr int
> max() noexcept { return 2147483647; }
>
>
> static constexpr int
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
> static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr int
> epsilon() noexcept { return 0; }
>
> static constexpr int
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr int
> infinity() noexcept { return static_cast<int>(0); }
>
> static constexpr int
> quiet_NaN() noexcept { return static_cast<int>(0); }
>
> static constexpr int
> signaling_NaN() noexcept { return static_cast<int>(0); }
>
> static constexpr int
> denorm_min() noexcept { return static_cast<int>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned int>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr unsigned int
> min() noexcept { return 0; }
>
> static constexpr unsigned int
> max() noexcept { return 2147483647 * 2U + 1; }
>
>
> static constexpr unsigned int
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr unsigned int
> epsilon() noexcept { return 0; }
>
> static constexpr unsigned int
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr unsigned int
> infinity() noexcept { return static_cast<unsigned int>(0); }
>
> static constexpr unsigned int
> quiet_NaN() noexcept
> { return static_cast<unsigned int>(0); }
>
> static constexpr unsigned int
> signaling_NaN() noexcept
> { return static_cast<unsigned int>(0); }
>
> static constexpr unsigned int
> denorm_min() noexcept
> { return static_cast<unsigned int>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<long>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr long
> min() noexcept { return -9223372036854775807L - 1; }
>
> static constexpr long
> max() noexcept { return 9223372036854775807L; }
>
>
> static constexpr long
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
> static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr long
> epsilon() noexcept { return 0; }
>
> static constexpr long
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr long
> infinity() noexcept { return static_cast<long>(0); }
>
> static constexpr long
> quiet_NaN() noexcept { return static_cast<long>(0); }
>
> static constexpr long
> signaling_NaN() noexcept { return static_cast<long>(0); }
>
> static constexpr long
> denorm_min() noexcept { return static_cast<long>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned long>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr unsigned long
> min() noexcept { return 0; }
>
> static constexpr unsigned long
> max() noexcept { return 9223372036854775807L * 2UL + 1; }
>
>
> static constexpr unsigned long
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr unsigned long
> epsilon() noexcept { return 0; }
>
> static constexpr unsigned long
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr unsigned long
> infinity() noexcept
> { return static_cast<unsigned long>(0); }
>
> static constexpr unsigned long
> quiet_NaN() noexcept
> { return static_cast<unsigned long>(0); }
>
> static constexpr unsigned long
> signaling_NaN() noexcept
> { return static_cast<unsigned long>(0); }
>
> static constexpr unsigned long
> denorm_min() noexcept
> { return static_cast<unsigned long>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<long long>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr long long
> min() noexcept { return -9223372036854775807LL - 1; }
>
> static constexpr long long
> max() noexcept { return 9223372036854775807LL; }
>
>
> static constexpr long long
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(long long) * 8 - ((long long)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr long long
> epsilon() noexcept { return 0; }
>
> static constexpr long long
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr long long
> infinity() noexcept { return static_cast<long long>(0); }
>
> static constexpr long long
> quiet_NaN() noexcept { return static_cast<long long>(0); }
>
> static constexpr long long
> signaling_NaN() noexcept
> { return static_cast<long long>(0); }
>
> static constexpr long long
> denorm_min() noexcept { return static_cast<long long>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned long long>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr unsigned long long
> min() noexcept { return 0; }
>
> static constexpr unsigned long long
> max() noexcept { return 9223372036854775807LL * 2ULL + 1; }
>
>
> static constexpr unsigned long long
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr unsigned long long
> epsilon() noexcept { return 0; }
>
> static constexpr unsigned long long
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr unsigned long long
> infinity() noexcept
> { return static_cast<unsigned long long>(0); }
>
> static constexpr unsigned long long
> quiet_NaN() noexcept
> { return static_cast<unsigned long long>(0); }
>
> static constexpr unsigned long long
> signaling_NaN() noexcept
> { return static_cast<unsigned long long>(0); }
>
> static constexpr unsigned long long
> denorm_min() noexcept
> { return static_cast<unsigned long long>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
># 1552 "/usr/include/c++/4.8.2/limits" 3
> template<>
> struct numeric_limits<float>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr float
> min() noexcept { return 1.17549435082228750797e-38F; }
>
> static constexpr float
> max() noexcept { return 3.40282346638528859812e+38F; }
>
>
> static constexpr float
> lowest() noexcept { return -3.40282346638528859812e+38F; }
>
>
> static constexpr int digits = 24;
> static constexpr int digits10 = 6;
>
> static constexpr int max_digits10
> = (2 + (24) * 643L / 2136);
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = false;
> static constexpr bool is_exact = false;
> static constexpr int radix = 2;
>
> static constexpr float
> epsilon() noexcept { return 1.19209289550781250000e-7F; }
>
> static constexpr float
> round_error() noexcept { return 0.5F; }
>
> static constexpr int min_exponent = (-125);
> static constexpr int min_exponent10 = (-37);
> static constexpr int max_exponent = 128;
> static constexpr int max_exponent10 = 38;
>
> static constexpr bool has_infinity = 1;
> static constexpr bool has_quiet_NaN = 1;
> static constexpr bool has_signaling_NaN = has_quiet_NaN;
> static constexpr float_denorm_style has_denorm
> = bool(1) ? denorm_present : denorm_absent;
> static constexpr bool has_denorm_loss
> = false;
>
> static constexpr float
> infinity() noexcept { return __builtin_huge_valf(); }
>
> static constexpr float
> quiet_NaN() noexcept { return __builtin_nanf(""); }
>
> static constexpr float
> signaling_NaN() noexcept { return __builtin_nansf(""); }
>
> static constexpr float
> denorm_min() noexcept { return 1.40129846432481707092e-45F; }
>
> static constexpr bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = false;
> static constexpr bool tinyness_before
> = false;
> static constexpr float_round_style round_style
> = round_to_nearest;
> };
>
>
>
>
>
>
> template<>
> struct numeric_limits<double>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr double
> min() noexcept { return double(2.22507385850720138309e-308L); }
>
> static constexpr double
> max() noexcept { return double(1.79769313486231570815e+308L); }
>
>
> static constexpr double
> lowest() noexcept { return -double(1.79769313486231570815e+308L); }
>
>
> static constexpr int digits = 53;
> static constexpr int digits10 = 15;
>
> static constexpr int max_digits10
> = (2 + (53) * 643L / 2136);
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = false;
> static constexpr bool is_exact = false;
> static constexpr int radix = 2;
>
> static constexpr double
> epsilon() noexcept { return double(2.22044604925031308085e-16L); }
>
> static constexpr double
> round_error() noexcept { return 0.5; }
>
> static constexpr int min_exponent = (-1021);
> static constexpr int min_exponent10 = (-307);
> static constexpr int max_exponent = 1024;
> static constexpr int max_exponent10 = 308;
>
> static constexpr bool has_infinity = 1;
> static constexpr bool has_quiet_NaN = 1;
> static constexpr bool has_signaling_NaN = has_quiet_NaN;
> static constexpr float_denorm_style has_denorm
> = bool(1) ? denorm_present : denorm_absent;
> static constexpr bool has_denorm_loss
> = false;
>
> static constexpr double
> infinity() noexcept { return __builtin_huge_val(); }
>
> static constexpr double
> quiet_NaN() noexcept { return __builtin_nan(""); }
>
> static constexpr double
> signaling_NaN() noexcept { return __builtin_nans(""); }
>
> static constexpr double
> denorm_min() noexcept { return double(4.94065645841246544177e-324L); }
>
> static constexpr bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = false;
> static constexpr bool tinyness_before
> = false;
> static constexpr float_round_style round_style
> = round_to_nearest;
> };
>
>
>
>
>
>
> template<>
> struct numeric_limits<long double>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr long double
> min() noexcept { return 3.36210314311209350626e-4932L; }
>
> static constexpr long double
> max() noexcept { return 1.18973149535723176502e+4932L; }
>
>
> static constexpr long double
> lowest() noexcept { return -1.18973149535723176502e+4932L; }
>
>
> static constexpr int digits = 64;
> static constexpr int digits10 = 18;
>
> static constexpr int max_digits10
> = (2 + (64) * 643L / 2136);
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = false;
> static constexpr bool is_exact = false;
> static constexpr int radix = 2;
>
> static constexpr long double
> epsilon() noexcept { return 1.08420217248550443401e-19L; }
>
> static constexpr long double
> round_error() noexcept { return 0.5L; }
>
> static constexpr int min_exponent = (-16381);
> static constexpr int min_exponent10 = (-4931);
> static constexpr int max_exponent = 16384;
> static constexpr int max_exponent10 = 4932;
>
> static constexpr bool has_infinity = 1;
> static constexpr bool has_quiet_NaN = 1;
> static constexpr bool has_signaling_NaN = has_quiet_NaN;
> static constexpr float_denorm_style has_denorm
> = bool(1) ? denorm_present : denorm_absent;
> static constexpr bool has_denorm_loss
> = false;
>
> static constexpr long double
> infinity() noexcept { return __builtin_huge_vall(); }
>
> static constexpr long double
> quiet_NaN() noexcept { return __builtin_nanl(""); }
>
> static constexpr long double
> signaling_NaN() noexcept { return __builtin_nansl(""); }
>
> static constexpr long double
> denorm_min() noexcept { return 3.64519953188247460253e-4951L; }
>
> static constexpr bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = false;
> static constexpr bool tinyness_before =
> false;
> static constexpr float_round_style round_style =
> round_to_nearest;
> };
>
>
>
>
>
>
>}
># 20 "/usr/include/boost/limits.hpp" 2 3 4
># 19 "/usr/include/boost/circular_buffer/base.hpp" 2 3 4
># 1 "/usr/include/boost/iterator/reverse_iterator.hpp" 1 3 4
># 10 "/usr/include/boost/iterator/reverse_iterator.hpp" 3 4
># 1 "/usr/include/boost/next_prior.hpp" 1 3 4
># 17 "/usr/include/boost/next_prior.hpp" 3 4
>namespace boost {
># 29 "/usr/include/boost/next_prior.hpp" 3 4
>template <class T>
>inline T next(T x) { return ++x; }
>
>template <class T, class Distance>
>inline T next(T x, Distance n)
>{
> std::advance(x, n);
> return x;
>}
>
>template <class T>
>inline T prior(T x) { return --x; }
>
>template <class T, class Distance>
>inline T prior(T x, Distance n)
>{
> std::advance(x, -n);
> return x;
>}
>
>}
># 11 "/usr/include/boost/iterator/reverse_iterator.hpp" 2 3 4
>
># 1 "/usr/include/boost/iterator/iterator_adaptor.hpp" 1 3 4
># 14 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
># 1 "/usr/include/boost/iterator/iterator_categories.hpp" 1 3 4
># 11 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
># 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
># 12 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/mpl/eval_if.hpp" 1 3 4
># 24 "/usr/include/boost/mpl/eval_if.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename C = na
> , typename F1 = na
> , typename F2 = na
> >
>struct eval_if
>
>
>
>
>{
> typedef typename if_<C,F1,F2>::type f_;
> typedef typename f_::type type;
>
>
>
>
> 
>};
>
>
>
>template<
> bool C
> , typename F1
> , typename F2
> >
>struct eval_if_c
>
>
>
>
>{
> typedef typename if_c<C,F1,F2>::type f_;
> typedef typename f_::type type;
>
>
>
>
>};
>
>template<> struct eval_if< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : eval_if< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< eval_if< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef eval_if< na , na , na > result_; typedef eval_if< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< eval_if< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< eval_if< na , na , na > > : int_<-1> { }; }
>
>}}
># 16 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/identity.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/identity.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename T = na
> >
>struct identity
>{
> typedef T type;
> 
>};
>
>template<
> typename T = na
> >
>struct make_identity
>{
> typedef identity<T> type;
> 
>};
>
>template<> struct identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : identity< T1 > { }; }; template< typename Tag > struct lambda< identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef identity< na > result_; typedef identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< identity< T1 > > : int_<1> { }; template<> struct template_arity< identity< na > > : int_<-1> { }; }
>template<> struct make_identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : make_identity< T1 > { }; }; template< typename Tag > struct lambda< make_identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef make_identity< na > result_; typedef make_identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< make_identity< T1 > > : int_<1> { }; template<> struct template_arity< make_identity< na > > : int_<-1> { }; }
>
>}}
># 17 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/placeholders.hpp" 1 3 4
># 24 "/usr/include/boost/mpl/placeholders.hpp" 3 4
># 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/arg.hpp" 3 4
># 1 "/usr/include/boost/mpl/arg_fwd.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/arg_fwd.hpp" 3 4
>namespace mpl_ {
>
>template< int N > struct arg;
>
>}
>namespace boost { namespace mpl { using ::mpl_::arg; } }
># 24 "/usr/include/boost/mpl/arg.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/aux_/na_assert.hpp" 1 3 4
># 26 "/usr/include/boost/mpl/arg.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/arity_spec.hpp" 1 3 4
># 27 "/usr/include/boost/mpl/arg.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/arg_typedef.hpp" 1 3 4
># 28 "/usr/include/boost/mpl/arg.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/mpl/aux_/config/use_preprocessed.hpp" 1 3 4
># 32 "/usr/include/boost/mpl/arg.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 16 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/compiler.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/preprocessor/stringize.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 1 3 4
># 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 3 4
>namespace mpl_ {
>template<> struct arg< -1 >
>{
> static const int value = -1;
> 
> 
>
> template<
> typename U1 = na, typename U2 = na, typename U3 = na
> , typename U4 = na, typename U5 = na
> >
> struct apply
> {
> typedef U1 type;
> enum { mpl_assertion_in_line_27 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
> };
>};
>
>template<> struct arg<1>
>{
> static const int value = 1;
> typedef arg<2> next;
> 
> 
>
> template<
> typename U1 = na, typename U2 = na, typename U3 = na
> , typename U4 = na, typename U5 = na
> >
> struct apply
> {
> typedef U1 type;
> enum { mpl_assertion_in_line_45 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
> };
>};
>
>template<> struct arg<2>
>{
> static const int value = 2;
> typedef arg<3> next;
> 
> 
>
> template<
> typename U1 = na, typename U2 = na, typename U3 = na
> , typename U4 = na, typename U5 = na
> >
> struct apply
> {
> typedef U2 type;
> enum { mpl_assertion_in_line_63 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
> };
>};
>
>template<> struct arg<3>
>{
> static const int value = 3;
> typedef arg<4> next;
> 
> 
>
> template<
> typename U1 = na, typename U2 = na, typename U3 = na
> , typename U4 = na, typename U5 = na
> >
> struct apply
> {
> typedef U3 type;
> enum { mpl_assertion_in_line_81 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
> };
>};
>
>template<> struct arg<4>
>{
> static const int value = 4;
> typedef arg<5> next;
> 
> 
>
> template<
> typename U1 = na, typename U2 = na, typename U3 = na
> , typename U4 = na, typename U5 = na
> >
> struct apply
> {
> typedef U4 type;
> enum { mpl_assertion_in_line_99 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
> };
>};
>
>template<> struct arg<5>
>{
> static const int value = 5;
> typedef arg<6> next;
> 
> 
>
> template<
> typename U1 = na, typename U2 = na, typename U3 = na
> , typename U4 = na, typename U5 = na
> >
> struct apply
> {
> typedef U5 type;
> enum { mpl_assertion_in_line_117 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
> };
>};
>
>
>
>}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 38 "/usr/include/boost/mpl/arg.hpp" 2 3 4
># 25 "/usr/include/boost/mpl/placeholders.hpp" 2 3 4
># 43 "/usr/include/boost/mpl/placeholders.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp" 1 3 4
># 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp" 3 4
>namespace mpl_ {
>typedef arg< -1 > _;
>}
>namespace boost { namespace mpl {
>
>using ::mpl_::_;
>
>namespace placeholders {
>using mpl_::_;
>}
>
>}}
>
>
>
>namespace mpl_ {
>typedef arg<1> _1;
>
>}
>namespace boost { namespace mpl {
>
>using ::mpl_::_1;
>
>namespace placeholders {
>using mpl_::_1;
>}
>
>}}
>namespace mpl_ {
>typedef arg<2> _2;
>
>}
>namespace boost { namespace mpl {
>
>using ::mpl_::_2;
>
>namespace placeholders {
>using mpl_::_2;
>}
>
>}}
>namespace mpl_ {
>typedef arg<3> _3;
>
>}
>namespace boost { namespace mpl {
>
>using ::mpl_::_3;
>
>namespace placeholders {
>using mpl_::_3;
>}
>
>}}
>namespace mpl_ {
>typedef arg<4> _4;
>
>}
>namespace boost { namespace mpl {
>
>using ::mpl_::_4;
>
>namespace placeholders {
>using mpl_::_4;
>}
>
>}}
>namespace mpl_ {
>typedef arg<5> _5;
>
>}
>namespace boost { namespace mpl {
>
>using ::mpl_::_5;
>
>namespace placeholders {
>using mpl_::_5;
>}
>
>}}
>namespace mpl_ {
>typedef arg<6> _6;
>
>}
>namespace boost { namespace mpl {
>
>using ::mpl_::_6;
>
>namespace placeholders {
>using mpl_::_6;
>}
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 44 "/usr/include/boost/mpl/placeholders.hpp" 2 3 4
># 18 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost {
>
>
>
>
>
>struct no_traversal_tag {};
>
>struct incrementable_traversal_tag
> : no_traversal_tag
>{
>
>
>};
>
>struct single_pass_traversal_tag
> : incrementable_traversal_tag
>{
>
>
>};
>
>struct forward_traversal_tag
> : single_pass_traversal_tag
>{
>
>
>};
>
>struct bidirectional_traversal_tag
> : forward_traversal_tag
>{
>
>
>};
>
>struct random_access_traversal_tag
> : bidirectional_traversal_tag
>{
>
>
>};
>
>namespace detail
>{
>
>
>
>
>
>
> template <class Cat>
> struct old_category_to_traversal
> : mpl::eval_if<
> is_convertible<Cat,std::random_access_iterator_tag>
> , mpl::identity<random_access_traversal_tag>
> , mpl::eval_if<
> is_convertible<Cat,std::bidirectional_iterator_tag>
> , mpl::identity<bidirectional_traversal_tag>
> , mpl::eval_if<
> is_convertible<Cat,std::forward_iterator_tag>
> , mpl::identity<forward_traversal_tag>
> , mpl::eval_if<
> is_convertible<Cat,std::input_iterator_tag>
> , mpl::identity<single_pass_traversal_tag>
> , mpl::eval_if<
> is_convertible<Cat,std::output_iterator_tag>
> , mpl::identity<incrementable_traversal_tag>
> , void
> >
> >
> >
> >
> >
> {};
># 108 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
> template <class Traversal>
> struct pure_traversal_tag
> : mpl::eval_if<
> is_convertible<Traversal,random_access_traversal_tag>
> , mpl::identity<random_access_traversal_tag>
> , mpl::eval_if<
> is_convertible<Traversal,bidirectional_traversal_tag>
> , mpl::identity<bidirectional_traversal_tag>
> , mpl::eval_if<
> is_convertible<Traversal,forward_traversal_tag>
> , mpl::identity<forward_traversal_tag>
> , mpl::eval_if<
> is_convertible<Traversal,single_pass_traversal_tag>
> , mpl::identity<single_pass_traversal_tag>
> , mpl::eval_if<
> is_convertible<Traversal,incrementable_traversal_tag>
> , mpl::identity<incrementable_traversal_tag>
> , void
> >
> >
> >
> >
> >
> {
> };
># 142 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
>}
>
>
>
>
>
>template <class Cat>
>struct iterator_category_to_traversal
> : mpl::eval_if<
> is_convertible<Cat,incrementable_traversal_tag>
> , mpl::identity<Cat>
> , boost::detail::old_category_to_traversal<Cat>
> >
>{};
>
>
>template <class Iterator = mpl::_1>
>struct iterator_traversal
> : iterator_category_to_traversal<
> typename boost::detail::iterator_traits<Iterator>::iterator_category
> >
>{};
># 184 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
>}
>
># 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
># 187 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
># 15 "/usr/include/boost/iterator/iterator_adaptor.hpp" 2 3 4
># 1 "/usr/include/boost/iterator/iterator_facade.hpp" 1 3 4
># 11 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
># 1 "/usr/include/boost/iterator/interoperable.hpp" 1 3 4
># 11 "/usr/include/boost/iterator/interoperable.hpp" 3 4
># 1 "/usr/include/boost/mpl/or.hpp" 1 3 4
># 43 "/usr/include/boost/mpl/or.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/or.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/or.hpp" 3 4
>namespace boost { namespace mpl {
>
>namespace aux {
>
>template< bool C_, typename T1, typename T2, typename T3, typename T4 >
>struct or_impl
> : true_
>{
>};
>
>template< typename T1, typename T2, typename T3, typename T4 >
>struct or_impl< false,T1,T2,T3,T4 >
> : or_impl<
> ::boost::mpl::aux::nested_type_wknd<T1>::value
> , T2, T3, T4
> , false_
> >
>{
>};
>
>template<>
>struct or_impl<
> false
> , false_, false_, false_, false_
> >
> : false_
>{
>};
>
>}
>
>template<
> typename T1 = na
> , typename T2 = na
> , typename T3 = false_, typename T4 = false_, typename T5 = false_
> >
>struct or_
>
> : aux::or_impl<
> ::boost::mpl::aux::nested_type_wknd<T1>::value
> , T2, T3, T4, T5
> >
>
>{
> 
>
>
>
>
>};
>
>template<> struct or_< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : or_< T1 , T2 > { }; }; template< typename Tag > struct lambda< or_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef or_< na , na > result_; typedef or_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< or_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< or_< na , na > > : int_<-1> { }; }
>
>
>
>
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 44 "/usr/include/boost/mpl/or.hpp" 2 3 4
># 12 "/usr/include/boost/iterator/interoperable.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
># 16 "/usr/include/boost/iterator/interoperable.hpp" 2 3 4
>
>namespace boost
>{
># 34 "/usr/include/boost/iterator/interoperable.hpp" 3 4
> template <typename A, typename B>
> struct is_interoperable
>
>
>
> : mpl::or_<
> is_convertible< A, B >
> , is_convertible< B, A > >
>
> {
> };
>
>}
>
># 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
># 49 "/usr/include/boost/iterator/interoperable.hpp" 2 3 4
># 12 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
># 1 "/usr/include/boost/iterator/iterator_traits.hpp" 1 3 4
># 11 "/usr/include/boost/iterator/iterator_traits.hpp" 3 4
>namespace boost {
># 27 "/usr/include/boost/iterator/iterator_traits.hpp" 3 4
>template <class Iterator>
>struct iterator_value
>{
> typedef typename boost::detail::iterator_traits<Iterator>::value_type type;
>};
>
>template <class Iterator>
>struct iterator_reference
>{
> typedef typename boost::detail::iterator_traits<Iterator>::reference type;
>};
>
>
>template <class Iterator>
>struct iterator_pointer
>{
> typedef typename boost::detail::iterator_traits<Iterator>::pointer type;
>};
>
>template <class Iterator>
>struct iterator_difference
>{
> typedef typename boost::detail::iterator_traits<Iterator>::difference_type type;
>};
>
>template <class Iterator>
>struct iterator_category
>{
> typedef typename boost::detail::iterator_traits<Iterator>::iterator_category type;
>};
># 90 "/usr/include/boost/iterator/iterator_traits.hpp" 3 4
>}
># 13 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
>
># 1 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 1 3 4
># 10 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 3 4
># 1 "/usr/include/boost/mpl/and.hpp" 1 3 4
># 42 "/usr/include/boost/mpl/and.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/and.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/and.hpp" 3 4
>namespace boost { namespace mpl {
>
>namespace aux {
>
>template< bool C_, typename T1, typename T2, typename T3, typename T4 >
>struct and_impl
> : false_
>{
>};
>
>template< typename T1, typename T2, typename T3, typename T4 >
>struct and_impl< true,T1,T2,T3,T4 >
> : and_impl<
> ::boost::mpl::aux::nested_type_wknd<T1>::value
> , T2, T3, T4
> , true_
> >
>{
>};
>
>template<>
>struct and_impl<
> true
> , true_, true_, true_, true_
> >
> : true_
>{
>};
>
>}
>
>template<
> typename T1 = na
> , typename T2 = na
> , typename T3 = true_, typename T4 = true_, typename T5 = true_
> >
>struct and_
>
> : aux::and_impl<
> ::boost::mpl::aux::nested_type_wknd<T1>::value
> , T2, T3, T4, T5
> >
>
>{
> 
>
>
>
>
>};
>
>template<> struct and_< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : and_< T1 , T2 > { }; }; template< typename Tag > struct lambda< and_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef and_< na , na > result_; typedef and_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< and_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< and_< na , na > > : int_<-1> { }; }
>
>
>
>
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 43 "/usr/include/boost/mpl/and.hpp" 2 3 4
># 11 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/is_const.hpp" 1 3 4
># 43 "/usr/include/boost/type_traits/is_const.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 44 "/usr/include/boost/type_traits/is_const.hpp" 2 3 4
>
>namespace boost {
>
>
>
>
>
>
>
>namespace detail{
>
>
>
>
>template <class T>
>struct is_const_rvalue_filter
>{
>
>
>
> static const bool value = ::boost::detail::cv_traits_imp<T*>::is_const;
>
>};
>
>template <class T>
>struct is_const_rvalue_filter<T&&>
>{
> static const bool value = false;
>};
>
>}
>
>
>template< typename T > struct is_const : public ::boost::integral_constant<bool,::boost::detail::is_const_rvalue_filter<T>::value> { public: };
>template< typename T > struct is_const< T& > : public ::boost::integral_constant<bool,false> { public: };
># 160 "/usr/include/boost/type_traits/is_const.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 163 "/usr/include/boost/type_traits/is_const.hpp" 2 3 4
># 18 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
># 24 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/detail/indirect_traits.hpp" 1 3 4
># 10 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_class.hpp" 1 3 4
># 37 "/usr/include/boost/type_traits/is_class.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 38 "/usr/include/boost/type_traits/is_class.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
># 120 "/usr/include/boost/type_traits/is_class.hpp" 3 4
>template <typename T>
>struct is_class_impl
>{
> static const bool value = __is_class(T);
>};
>
>
>}
>
>
>
>
>
>template< typename T > struct is_class : public ::boost::integral_constant<bool,::boost::detail::is_class_impl<T>::value> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 139 "/usr/include/boost/type_traits/is_class.hpp" 2 3 4
># 11 "/usr/include/boost/detail/indirect_traits.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/remove_reference.hpp" 1 3 4
># 21 "/usr/include/boost/type_traits/remove_reference.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 22 "/usr/include/boost/type_traits/remove_reference.hpp" 2 3 4
>
>namespace boost {
>
>
>
>namespace detail{
>
>
>
>
>template <class T>
>struct remove_rvalue_ref
>{
> typedef T type;
>};
>
>template <class T>
>struct remove_rvalue_ref<T&&>
>{
> typedef T type;
>};
>
>
>}
>
>template< typename T > struct remove_reference { public: typedef typename boost::detail::remove_rvalue_ref<T>::type type; };
>template< typename T > struct remove_reference<T&> { public: typedef T type; };
># 66 "/usr/include/boost/type_traits/remove_reference.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 69 "/usr/include/boost/type_traits/remove_reference.hpp" 2 3 4
># 17 "/usr/include/boost/detail/indirect_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/remove_pointer.hpp" 1 3 4
># 26 "/usr/include/boost/type_traits/remove_pointer.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 27 "/usr/include/boost/type_traits/remove_pointer.hpp" 2 3 4
>
>namespace boost {
># 76 "/usr/include/boost/type_traits/remove_pointer.hpp" 3 4
>template< typename T > struct remove_pointer { public: typedef T type; };
>template< typename T > struct remove_pointer<T*> { public: typedef T type; };
>template< typename T > struct remove_pointer<T* const> { public: typedef T type; };
>template< typename T > struct remove_pointer<T* volatile> { public: typedef T type; };
>template< typename T > struct remove_pointer<T* const volatile> { public: typedef T type; };
>
>
>
>
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 91 "/usr/include/boost/type_traits/remove_pointer.hpp" 2 3 4
># 18 "/usr/include/boost/detail/indirect_traits.hpp" 2 3 4
># 33 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
>namespace boost { namespace detail {
>
>namespace indirect_traits {
>
>
>template <class T>
>struct is_reference_to_const : mpl::false_
>{
>};
>
>template <class T>
>struct is_reference_to_const<T const&> : mpl::true_
>{
>};
># 55 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
>template <class T>
>struct is_reference_to_function : mpl::false_
>{
>};
>
>template <class T>
>struct is_reference_to_function<T&> : is_function<T>
>{
>};
>
>template <class T>
>struct is_pointer_to_function : mpl::false_
>{
>};
>
>
>
>template <class T>
>struct is_pointer_to_function<T*> : is_function<T>
>{
>};
>
>template <class T>
>struct is_reference_to_member_function_pointer_impl : mpl::false_
>{
>};
>
>template <class T>
>struct is_reference_to_member_function_pointer_impl<T&>
> : is_member_function_pointer<typename remove_cv<T>::type>
>{
>};
>
>
>template <class T>
>struct is_reference_to_member_function_pointer
> : is_reference_to_member_function_pointer_impl<T>
>{
> 
>};
>
>template <class T>
>struct is_reference_to_function_pointer_aux
> : mpl::and_<
> is_reference<T>
> , is_pointer_to_function<
> typename remove_cv<
> typename remove_reference<T>::type
> >::type
> >
> >
>{
>
>};
>
>template <class T>
>struct is_reference_to_function_pointer
> : mpl::if_<
> is_reference_to_function<T>
> , mpl::false_
> , is_reference_to_function_pointer_aux<T>
> >::type
>{
>};
>
>template <class T>
>struct is_reference_to_non_const
> : mpl::and_<
> is_reference<T>
> , mpl::not_<
> is_reference_to_const<T>
> >
> >
>{
>};
>
>template <class T>
>struct is_reference_to_volatile : mpl::false_
>{
>};
>
>template <class T>
>struct is_reference_to_volatile<T volatile&> : mpl::true_
>{
>};
># 149 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
>template <class T>
>struct is_reference_to_pointer : mpl::false_
>{
>};
>
>template <class T>
>struct is_reference_to_pointer<T*&> : mpl::true_
>{
>};
>
>template <class T>
>struct is_reference_to_pointer<T* const&> : mpl::true_
>{
>};
>
>template <class T>
>struct is_reference_to_pointer<T* volatile&> : mpl::true_
>{
>};
>
>template <class T>
>struct is_reference_to_pointer<T* const volatile&> : mpl::true_
>{
>};
>
>template <class T>
>struct is_reference_to_class
> : mpl::and_<
> is_reference<T>
> , is_class<
> typename remove_cv<
> typename remove_reference<T>::type
> >::type
> >
> >
>{
> 
>};
>
>template <class T>
>struct is_pointer_to_class
> : mpl::and_<
> is_pointer<T>
> , is_class<
> typename remove_cv<
> typename remove_pointer<T>::type
> >::type
> >
> >
>{
> 
>};
># 481 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
>}
>
>using namespace indirect_traits;
>
>}}
># 27 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost { struct use_default; }
>
>namespace boost { namespace detail {
>
>struct input_output_iterator_tag
> : std::input_iterator_tag
>{
>
>
>
>
>
>
> operator std::output_iterator_tag() const
> {
> return std::output_iterator_tag();
> }
>};
>
>
>
>
>
>
>template <class ValueParam, class Reference>
>struct iterator_writability_disabled
>
> : mpl::or_<
> is_const<Reference>
> , boost::detail::indirect_traits::is_reference_to_const<Reference>
> , is_const<ValueParam>
> >
>
>
>
>{};
># 86 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 3 4
>template <class Traversal, class ValueParam, class Reference>
>struct iterator_facade_default_category
> : mpl::eval_if<
> mpl::and_<
> is_reference<Reference>
> , is_convertible<Traversal,forward_traversal_tag>
> >
> , mpl::eval_if<
> is_convertible<Traversal,random_access_traversal_tag>
> , mpl::identity<std::random_access_iterator_tag>
> , mpl::if_<
> is_convertible<Traversal,bidirectional_traversal_tag>
> , std::bidirectional_iterator_tag
> , std::forward_iterator_tag
> >
> >
> , typename mpl::eval_if<
> mpl::and_<
> is_convertible<Traversal, single_pass_traversal_tag>
>
>
> , is_convertible<Reference, ValueParam>
> >
> , mpl::identity<std::input_iterator_tag>
> , mpl::identity<Traversal>
> >
> >
>{
>};
>
>
>template <class T>
>struct is_iterator_category
> : mpl::or_<
> is_convertible<T,std::input_iterator_tag>
> , is_convertible<T,std::output_iterator_tag>
> >
>{
>};
>
>template <class T>
>struct is_iterator_traversal
> : is_convertible<T,incrementable_traversal_tag>
>{};
>
>
>
>
>
>
>
>template <class Category, class Traversal>
>struct iterator_category_with_traversal
> : Category, Traversal
>{
>
>
>
>
> enum { mpl_assertion_in_line_149 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) ( is_convertible< typename iterator_category_to_traversal<Category>::type , Traversal >))0, 1 ) ) ) }
>
>
>
> ;
>
> enum { mpl_assertion_in_line_151 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_iterator_category<Category>))0, 1 ) ) ) };
> enum { mpl_assertion_in_line_152 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_category<Traversal>))0, 1 ) ) ) };
> enum { mpl_assertion_in_line_153 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_traversal<Category>))0, 1 ) ) ) };
>
> enum { mpl_assertion_in_line_155 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_iterator_traversal<Traversal>))0, 1 ) ) ) };
>
>
>};
>
>
>
>template <class Traversal, class ValueParam, class Reference>
>struct facade_iterator_category_impl
>{
>
> enum { mpl_assertion_in_line_166 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_category<Traversal>))0, 1 ) ) ) };
>
>
> typedef typename iterator_facade_default_category<
> Traversal,ValueParam,Reference
> >::type category;
>
> typedef typename mpl::if_<
> is_same<
> Traversal
> , typename iterator_category_to_traversal<category>::type
> >
> , category
> , iterator_category_with_traversal<category,Traversal>
> >::type type;
>};
>
>
>
>
>template <class CategoryOrTraversal, class ValueParam, class Reference>
>struct facade_iterator_category
> : mpl::eval_if<
> is_iterator_category<CategoryOrTraversal>
> , mpl::identity<CategoryOrTraversal>
> , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>
> >
>{
>};
>
>}}
>
># 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
># 199 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
># 15 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
># 1 "/usr/include/boost/iterator/detail/enable_if.hpp" 1 3 4
># 13 "/usr/include/boost/iterator/detail/enable_if.hpp" 3 4
># 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
># 14 "/usr/include/boost/iterator/detail/enable_if.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost
>{
>
> namespace iterators
> {
>
>
>
> template<bool>
> struct enabled
> {
> template<typename T>
> struct base
> {
> typedef T type;
> };
> };
>
>
>
>
>
>
> template<>
> struct enabled<false>
> {
> template<typename T>
> struct base
> {
># 62 "/usr/include/boost/iterator/detail/enable_if.hpp" 3 4
> };
> };
>
>
> template <class Cond,
> class Return>
> struct enable_if
>
> : enabled<(Cond::value)>::template base<Return>
>
>
>
> {
>
>
>
> };
>
> }
>
>}
>
># 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
># 85 "/usr/include/boost/iterator/detail/enable_if.hpp" 2 3 4
># 16 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/utility/addressof.hpp" 1 3 4
># 18 "/usr/include/boost/utility/addressof.hpp" 3 4
>namespace boost
>{
>
>namespace detail
>{
>
>template<class T> struct addr_impl_ref
>{
> T & v_;
>
> inline addr_impl_ref( T & v ): v_( v ) {}
> inline operator T& () const { return v_; }
>
>private:
> addr_impl_ref & operator=(const addr_impl_ref &);
>};
>
>template<class T> struct addressof_impl
>{
> static inline T * f( T & v, long )
> {
> return reinterpret_cast<T*>(
> &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
> }
>
> static inline T * f( T * v, int )
> {
> return v;
> }
>};
>
>}
>
>template<class T> T * addressof( T & v )
>{
>
>
>
>
>
>
> return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );
>
>
>}
># 100 "/usr/include/boost/utility/addressof.hpp" 3 4
>}
># 19 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/type_traits/add_const.hpp" 1 3 4
># 16 "/usr/include/boost/type_traits/add_const.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 17 "/usr/include/boost/type_traits/add_const.hpp" 2 3 4
>
>namespace boost {
># 33 "/usr/include/boost/type_traits/add_const.hpp" 3 4
>template< typename T > struct add_const { public: typedef T const type; };
>
>
>
>
>
>
>template< typename T > struct add_const<T&> { public: typedef T& type; };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 46 "/usr/include/boost/type_traits/add_const.hpp" 2 3 4
># 22 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/add_pointer.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/add_pointer.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 16 "/usr/include/boost/type_traits/add_pointer.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
># 55 "/usr/include/boost/type_traits/add_pointer.hpp" 3 4
>template <typename T>
>struct add_pointer_impl
>{
> typedef typename remove_reference<T>::type no_ref_type;
> typedef no_ref_type* type;
>};
>
>
>
>}
>
>template< typename T > struct add_pointer { public: typedef typename boost::detail::add_pointer_impl<T>::type type; };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 71 "/usr/include/boost/type_traits/add_pointer.hpp" 2 3 4
># 23 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/remove_const.hpp" 1 3 4
># 20 "/usr/include/boost/type_traits/remove_const.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 21 "/usr/include/boost/type_traits/remove_const.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 28 "/usr/include/boost/type_traits/remove_const.hpp" 2 3 4
>
>namespace boost {
>
>
>
>namespace detail {
>
>template <typename T, bool is_vol>
>struct remove_const_helper
>{
> typedef T type;
>};
>
>template <typename T>
>struct remove_const_helper<T, true>
>{
> typedef T volatile type;
>};
>
>
>template <typename T>
>struct remove_const_impl
>{
> typedef typename remove_const_helper<
> typename cv_traits_imp<T*>::unqualified_type
> , ::boost::is_volatile<T>::value
> >::type type;
>};
>
>
>
>
>
>
>template <typename T>
>struct remove_const_impl<T&&>
>{
> typedef T&& type;
>};
>
>
>}
>
>
>
>template< typename T > struct remove_const { public: typedef typename boost::detail::remove_const_impl<T>::type type; };
>template< typename T > struct remove_const<T&> { public: typedef T& type; };
>
>template< typename T, std::size_t N > struct remove_const<T const[N]> { public: typedef T type[N]; };
>template< typename T, std::size_t N > struct remove_const<T const volatile[N]> { public: typedef T volatile type[N]; };
># 86 "/usr/include/boost/type_traits/remove_const.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 89 "/usr/include/boost/type_traits/remove_const.hpp" 2 3 4
># 24 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/type_traits/is_pod.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/is_pod.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_scalar.hpp" 1 3 4
># 20 "/usr/include/boost/type_traits/is_scalar.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 21 "/usr/include/boost/type_traits/is_scalar.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
>
>template <typename T>
>struct is_scalar_impl
>{
> static const bool value = (::boost::type_traits::ice_or< ::boost::is_arithmetic<T>::value, ::boost::is_enum<T>::value, ::boost::is_pointer<T>::value, ::boost::is_member_pointer<T>::value >::value)
>
>
>
>
>
> ;
>};
>
>
>
>template <> struct is_scalar_impl<void>{ static const bool value = false; };
>
>template <> struct is_scalar_impl<void const>{ static const bool value = false; };
>template <> struct is_scalar_impl<void volatile>{ static const bool value = false; };
>template <> struct is_scalar_impl<void const volatile>{ static const bool value = false; };
>
>
>}
>
>template< typename T > struct is_scalar : public ::boost::integral_constant<bool,::boost::detail::is_scalar_impl<T>::value> { public: };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 54 "/usr/include/boost/type_traits/is_scalar.hpp" 2 3 4
># 15 "/usr/include/boost/type_traits/is_pod.hpp" 2 3 4
>
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 19 "/usr/include/boost/type_traits/is_pod.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 22 "/usr/include/boost/type_traits/is_pod.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost {
>
>
>template< typename T > struct is_POD;
>
>namespace detail {
>
>
>
>template <typename T> struct is_pod_impl
>{
> static const bool value = (::boost::type_traits::ice_or< ::boost::is_scalar<T>::value, ::boost::is_void<T>::value, __is_pod(T) >::value)
>
>
>
>
>
> ;
>};
>
>
>template <typename T, std::size_t sz>
>struct is_pod_impl<T[sz]>
> : public is_pod_impl<T>
>{
>};
># 124 "/usr/include/boost/type_traits/is_pod.hpp" 3 4
>template<> struct is_pod_impl< void > { public: static const bool value = (true); };
>
>
>template<> struct is_pod_impl< void const > { public: static const bool value = (true); };
>template<> struct is_pod_impl< void volatile > { public: static const bool value = (true); };
>template<> struct is_pod_impl< void const volatile > { public: static const bool value = (true); };
>
>
>}
>
>template< typename T > struct is_pod : public ::boost::integral_constant<bool,::boost::detail::is_pod_impl<T>::value> { public: };
>
>
>template< typename T > struct is_POD : public ::boost::integral_constant<bool,::boost::is_pod<T>::value> { public: };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 142 "/usr/include/boost/type_traits/is_pod.hpp" 2 3 4
># 27 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/mpl/always.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/always.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Value > struct always
>{
> template<
> typename T
> , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na
> >
> struct apply
> {
> typedef Value type;
> };
>};
>
>
>
>}}
># 34 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/apply.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply_fwd.hpp" 1 3 4
># 31 "/usr/include/boost/mpl/apply_fwd.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename F, typename T1 = na, typename T2 = na, typename T3 = na
> , typename T4 = na, typename T5 = na
> >
>struct apply;
>
>template<
> typename F
> >
>struct apply0;
>
>template<
> typename F, typename T1
> >
>struct apply1;
>
>template<
> typename F, typename T1, typename T2
> >
>struct apply2;
>
>template<
> typename F, typename T1, typename T2, typename T3
> >
>struct apply3;
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> >
>struct apply4;
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> , typename T5
> >
>struct apply5;
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 32 "/usr/include/boost/mpl/apply_fwd.hpp" 2 3 4
># 23 "/usr/include/boost/mpl/apply.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/apply_wrap.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/has_apply.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/has_apply.hpp" 3 4
># 1 "/usr/include/boost/mpl/has_xxx.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/type_wrapper.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/aux_/type_wrapper.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>template< typename T > struct type_wrapper
>{
> typedef T type;
>};
>
>
>
>
>
>
>template< typename T > struct wrapped_type;
>
>template< typename T > struct wrapped_type< type_wrapper<T> >
>{
> typedef T type;
>};
>
>
>
>
>
>
>
>}}}
># 22 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/aux_/config/has_xxx.hpp" 1 3 4
># 25 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/msvc_typename.hpp" 1 3 4
># 26 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/preprocessor/array/elem.hpp" 1 3 4
># 15 "/usr/include/boost/preprocessor/array/elem.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/array/data.hpp" 1 3 4
># 16 "/usr/include/boost/preprocessor/array/elem.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/array/size.hpp" 1 3 4
># 17 "/usr/include/boost/preprocessor/array/elem.hpp" 2 3 4
># 31 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/preprocessor/repetition/enum_params.hpp" 1 3 4
># 34 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/repetition/enum_trailing_params.hpp" 1 3 4
># 35 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
># 18 "/usr/include/boost/mpl/aux_/has_apply.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/has_apply.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/has_apply.hpp" 2 3 4
>
>namespace boost { namespace mpl { namespace aux {
>
>template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_apply { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper const volatile* , boost::mpl::aux::type_wrapper<typename U::apply>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
>
>
>
>
>
>
>
>}}}
># 24 "/usr/include/boost/mpl/apply_wrap.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/aux_/msvc_never_true.hpp" 1 3 4
># 26 "/usr/include/boost/mpl/apply_wrap.hpp" 2 3 4
># 34 "/usr/include/boost/mpl/apply_wrap.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename F
>
> , typename has_apply_ = typename aux::has_apply<F>::type
>
> >
>struct apply_wrap0
>
> : F::template apply< >
>{
>};
>
>template< typename F >
>struct apply_wrap0< F,true_ >
> : F::apply
>{
>};
>
>template<
> typename F, typename T1
>
> >
>struct apply_wrap1
>
> : F::template apply<T1>
>{
>};
>
>template<
> typename F, typename T1, typename T2
>
> >
>struct apply_wrap2
>
> : F::template apply< T1,T2 >
>{
>};
>
>template<
> typename F, typename T1, typename T2, typename T3
>
> >
>struct apply_wrap3
>
> : F::template apply< T1,T2,T3 >
>{
>};
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
>
> >
>struct apply_wrap4
>
> : F::template apply< T1,T2,T3,T4 >
>{
>};
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> , typename T5
>
> >
>struct apply_wrap5
>
> : F::template apply< T1,T2,T3,T4,T5 >
>{
>};
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 35 "/usr/include/boost/mpl/apply_wrap.hpp" 2 3 4
># 24 "/usr/include/boost/mpl/apply.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/placeholders.hpp" 1 3 4
># 25 "/usr/include/boost/mpl/apply.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/lambda.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/lambda.hpp" 3 4
># 1 "/usr/include/boost/mpl/bind.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/bind.hpp" 3 4
># 1 "/usr/include/boost/mpl/bind_fwd.hpp" 1 3 4
># 25 "/usr/include/boost/mpl/bind_fwd.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/bind.hpp" 1 3 4
># 26 "/usr/include/boost/mpl/bind_fwd.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename F, typename T1 = na, typename T2 = na, typename T3 = na
> , typename T4 = na, typename T5 = na
> >
>struct bind;
>
>template<
> typename F
> >
>struct bind0;
>
>template<
> typename F, typename T1
> >
>struct bind1;
>
>template<
> typename F, typename T1, typename T2
> >
>struct bind2;
>
>template<
> typename F, typename T1, typename T2, typename T3
> >
>struct bind3;
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> >
>struct bind4;
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> , typename T5
> >
>struct bind5;
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 33 "/usr/include/boost/mpl/bind_fwd.hpp" 2 3 4
># 24 "/usr/include/boost/mpl/bind.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/placeholders.hpp" 1 3 4
># 25 "/usr/include/boost/mpl/bind.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/next.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/next.hpp" 3 4
># 1 "/usr/include/boost/mpl/next_prior.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/next_prior.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/common_name_wknd.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/next_prior.hpp" 2 3 4
>
>
>
>namespace boost { namespace mpl {
>
>
>
>
>template<
> typename T = na
> >
>struct next
>{
> typedef typename T::next type;
> 
>};
>
>template<
> typename T = na
> >
>struct prior
>{
> typedef typename T::prior type;
> 
>};
>
>template<> struct next< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : next< T1 > { }; }; template< typename Tag > struct lambda< next< na > , Tag , int_<-1> > { typedef false_ is_le; typedef next< na > result_; typedef next< na > type; }; namespace aux { template< typename T1 > struct template_arity< next< T1 > > : int_<1> { }; template<> struct template_arity< next< na > > : int_<-1> { }; }
>template<> struct prior< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : prior< T1 > { }; }; template< typename Tag > struct lambda< prior< na > , Tag , int_<-1> > { typedef false_ is_le; typedef prior< na > result_; typedef prior< na > type; }; namespace aux { template< typename T1 > struct template_arity< prior< T1 > > : int_<1> { }; template<> struct template_arity< prior< na > > : int_<-1> { }; }
>
>}}
># 18 "/usr/include/boost/mpl/next.hpp" 2 3 4
># 26 "/usr/include/boost/mpl/bind.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/protect.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/protect.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename T = na
> , int not_le_ = 0
> >
>struct protect : T
>{
>
>
>
> typedef protect type;
>
>};
># 48 "/usr/include/boost/mpl/protect.hpp" 3 4
>template<> struct protect< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : protect< T1 > { }; };
>
>namespace aux { template< typename T1 > struct template_arity< protect< T1 > > : int_<1> { }; template<> struct template_arity< protect< na > > : int_<-1> { }; }
>
>
>}}
># 27 "/usr/include/boost/mpl/bind.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
># 28 "/usr/include/boost/mpl/bind.hpp" 2 3 4
># 50 "/usr/include/boost/mpl/bind.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp" 1 3 4
># 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp" 3 4
>namespace boost { namespace mpl {
>
>namespace aux {
>
>template<
> typename T, typename U1, typename U2, typename U3, typename U4
> , typename U5
> >
>struct resolve_bind_arg
>{
> typedef T type;
>};
>
>template<
> typename T
> , typename Arg
> >
>struct replace_unnamed_arg
>{
> typedef Arg next;
> typedef T type;
>};
>
>template<
> typename Arg
> >
>struct replace_unnamed_arg< arg< -1 >, Arg >
>{
> typedef typename Arg::next next;
> typedef Arg type;
>};
>
>template<
> int N, typename U1, typename U2, typename U3, typename U4, typename U5
> >
>struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
>{
> typedef typename apply_wrap5<mpl::arg<N>, U1, U2, U3, U4, U5>::type type;
>};
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename U1, typename U2, typename U3, typename U4
> , typename U5
> >
>struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 >
>{
> typedef bind< F,T1,T2,T3,T4,T5 > f_;
> typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
>};
>
>}
>
>template<
> typename F
> >
>struct bind0
>{
> template<
> typename U1 = na, typename U2 = na, typename U3 = na
> , typename U4 = na, typename U5 = na
> >
> struct apply
> {
> private:
> typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
> typedef typename r0::type a0;
> typedef typename r0::next n1;
> typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
>
> public:
> typedef typename apply_wrap0<
> f_
> >::type type;
>
> };
>};
>
>namespace aux {
>
>template<
> typename F, typename U1, typename U2, typename U3, typename U4
> , typename U5
> >
>struct resolve_bind_arg<
> bind0<F>, U1, U2, U3, U4, U5
> >
>{
> typedef bind0<F> f_;
> typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
>};
>
>}
>
>
>namespace aux { template< typename T1 > struct template_arity< bind0< T1> > : int_<1> { }; }
>
>template<
> typename F
> >
>struct bind< F,na,na,na,na,na >
> : bind0<F>
>{
>};
>
>template<
> typename F, typename T1
> >
>struct bind1
>{
> template<
> typename U1 = na, typename U2 = na, typename U3 = na
> , typename U4 = na, typename U5 = na
> >
> struct apply
> {
> private:
> typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
> typedef typename r0::type a0;
> typedef typename r0::next n1;
> typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
>
> typedef aux::replace_unnamed_arg< T1,n1 > r1;
> typedef typename r1::type a1;
> typedef typename r1::next n2;
> typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
>
> public:
> typedef typename apply_wrap1<
> f_
> , typename t1::type
> >::type type;
>
> };
>};
>
>namespace aux {
>
>template<
> typename F, typename T1, typename U1, typename U2, typename U3
> , typename U4, typename U5
> >
>struct resolve_bind_arg<
> bind1< F,T1 >, U1, U2, U3, U4, U5
> >
>{
> typedef bind1< F,T1 > f_;
> typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
>};
>
>}
>
>
>namespace aux { template< typename T1 , typename T2 > struct template_arity< bind1< T1 , T2> > : int_<2> { }; }
>
>template<
> typename F, typename T1
> >
>struct bind< F,T1,na,na,na,na >
> : bind1< F,T1 >
>{
>};
>
>template<
> typename F, typename T1, typename T2
> >
>struct bind2
>{
> template<
> typename U1 = na, typename U2 = na, typename U3 = na
> , typename U4 = na, typename U5 = na
> >
> struct apply
> {
> private:
> typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
> typedef typename r0::type a0;
> typedef typename r0::next n1;
> typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
>
> typedef aux::replace_unnamed_arg< T1,n1 > r1;
> typedef typename r1::type a1;
> typedef typename r1::next n2;
> typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
>
> typedef aux::replace_unnamed_arg< T2,n2 > r2;
> typedef typename r2::type a2;
> typedef typename r2::next n3;
> typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
>
> public:
> typedef typename apply_wrap2<
> f_
> , typename t1::type, typename t2::type
> >::type type;
>
> };
>};
>
>namespace aux {
>
>template<
> typename F, typename T1, typename T2, typename U1, typename U2
> , typename U3, typename U4, typename U5
> >
>struct resolve_bind_arg<
> bind2< F,T1,T2 >, U1, U2, U3, U4, U5
> >
>{
> typedef bind2< F,T1,T2 > f_;
> typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
>};
>
>}
>
>
>namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< bind2< T1 , T2 , T3> > : int_<3> { }; }
>
>template<
> typename F, typename T1, typename T2
> >
>struct bind< F,T1,T2,na,na,na >
> : bind2< F,T1,T2 >
>{
>};
>
>template<
> typename F, typename T1, typename T2, typename T3
> >
>struct bind3
>{
> template<
> typename U1 = na, typename U2 = na, typename U3 = na
> , typename U4 = na, typename U5 = na
> >
> struct apply
> {
> private:
> typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
> typedef typename r0::type a0;
> typedef typename r0::next n1;
> typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
>
> typedef aux::replace_unnamed_arg< T1,n1 > r1;
> typedef typename r1::type a1;
> typedef typename r1::next n2;
> typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
>
> typedef aux::replace_unnamed_arg< T2,n2 > r2;
> typedef typename r2::type a2;
> typedef typename r2::next n3;
> typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
>
> typedef aux::replace_unnamed_arg< T3,n3 > r3;
> typedef typename r3::type a3;
> typedef typename r3::next n4;
> typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
>
> public:
> typedef typename apply_wrap3<
> f_
> , typename t1::type, typename t2::type, typename t3::type
> >::type type;
>
> };
>};
>
>namespace aux {
>
>template<
> typename F, typename T1, typename T2, typename T3, typename U1
> , typename U2, typename U3, typename U4, typename U5
> >
>struct resolve_bind_arg<
> bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
> >
>{
> typedef bind3< F,T1,T2,T3 > f_;
> typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
>};
>
>}
>
>
>namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< bind3< T1 , T2 , T3 , T4> > : int_<4> { }; }
>
>template<
> typename F, typename T1, typename T2, typename T3
> >
>struct bind< F,T1,T2,T3,na,na >
> : bind3< F,T1,T2,T3 >
>{
>};
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> >
>struct bind4
>{
> template<
> typename U1 = na, typename U2 = na, typename U3 = na
> , typename U4 = na, typename U5 = na
> >
> struct apply
> {
> private:
> typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
> typedef typename r0::type a0;
> typedef typename r0::next n1;
> typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
>
> typedef aux::replace_unnamed_arg< T1,n1 > r1;
> typedef typename r1::type a1;
> typedef typename r1::next n2;
> typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
>
> typedef aux::replace_unnamed_arg< T2,n2 > r2;
> typedef typename r2::type a2;
> typedef typename r2::next n3;
> typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
>
> typedef aux::replace_unnamed_arg< T3,n3 > r3;
> typedef typename r3::type a3;
> typedef typename r3::next n4;
> typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
>
> typedef aux::replace_unnamed_arg< T4,n4 > r4;
> typedef typename r4::type a4;
> typedef typename r4::next n5;
> typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;
>
> public:
> typedef typename apply_wrap4<
> f_
> , typename t1::type, typename t2::type, typename t3::type
> , typename t4::type
> >::type type;
>
> };
>};
>
>namespace aux {
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> , typename U1, typename U2, typename U3, typename U4, typename U5
> >
>struct resolve_bind_arg<
> bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
> >
>{
> typedef bind4< F,T1,T2,T3,T4 > f_;
> typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
>};
>
>}
>
>
>namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< bind4< T1 , T2 , T3 , T4 , T5> > : int_<5> { }; }
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> >
>struct bind< F,T1,T2,T3,T4,na >
> : bind4< F,T1,T2,T3,T4 >
>{
>};
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> , typename T5
> >
>struct bind5
>{
> template<
> typename U1 = na, typename U2 = na, typename U3 = na
> , typename U4 = na, typename U5 = na
> >
> struct apply
> {
> private:
> typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
> typedef typename r0::type a0;
> typedef typename r0::next n1;
> typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
>
> typedef aux::replace_unnamed_arg< T1,n1 > r1;
> typedef typename r1::type a1;
> typedef typename r1::next n2;
> typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
>
> typedef aux::replace_unnamed_arg< T2,n2 > r2;
> typedef typename r2::type a2;
> typedef typename r2::next n3;
> typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
>
> typedef aux::replace_unnamed_arg< T3,n3 > r3;
> typedef typename r3::type a3;
> typedef typename r3::next n4;
> typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
>
> typedef aux::replace_unnamed_arg< T4,n4 > r4;
> typedef typename r4::type a4;
> typedef typename r4::next n5;
> typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;
>
> typedef aux::replace_unnamed_arg< T5,n5 > r5;
> typedef typename r5::type a5;
> typedef typename r5::next n6;
> typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5;
>
> public:
> typedef typename apply_wrap5<
> f_
> , typename t1::type, typename t2::type, typename t3::type
> , typename t4::type, typename t5::type
> >::type type;
>
> };
>};
>
>namespace aux {
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename U1, typename U2, typename U3, typename U4
> , typename U5
> >
>struct resolve_bind_arg<
> bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
> >
>{
> typedef bind5< F,T1,T2,T3,T4,T5 > f_;
> typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
>};
>
>}
>
>
>namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct template_arity< bind5< T1 , T2 , T3 , T4 , T5 , T6> > : int_<6> { }; }
>
>
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> , typename T5
> >
>struct bind
> : bind5< F,T1,T2,T3,T4,T5 >
>{
>};
>
>
>template< template< typename T1, typename T2, typename T3 > class F, typename Tag >
>struct quote3;
>
>template< typename T1, typename T2, typename T3 > struct if_;
>
>template<
> typename Tag, typename T1, typename T2, typename T3
> >
>struct bind3<
> quote3< if_,Tag >
> , T1, T2, T3
> >
>{
> template<
> typename U1 = na, typename U2 = na, typename U3 = na
> , typename U4 = na, typename U5 = na
> >
> struct apply
> {
> private:
> typedef mpl::arg<1> n1;
> typedef aux::replace_unnamed_arg< T1,n1 > r1;
> typedef typename r1::type a1;
> typedef typename r1::next n2;
> typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
>
> typedef aux::replace_unnamed_arg< T2,n2 > r2;
> typedef typename r2::type a2;
> typedef typename r2::next n3;
> typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
>
> typedef aux::replace_unnamed_arg< T3,n3 > r3;
> typedef typename r3::type a3;
> typedef typename r3::next n4;
> typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
>
> typedef typename if_<
> typename t1::type
> , t2, t3
> >::type f_;
>
> public:
> typedef typename f_::type type;
> };
>};
>
>template<
> template< typename T1, typename T2, typename T3 > class F, typename Tag
> >
>struct quote3;
>
>template< typename T1, typename T2, typename T3 > struct eval_if;
>
>template<
> typename Tag, typename T1, typename T2, typename T3
> >
>struct bind3<
> quote3< eval_if,Tag >
> , T1, T2, T3
> >
>{
> template<
> typename U1 = na, typename U2 = na, typename U3 = na
> , typename U4 = na, typename U5 = na
> >
> struct apply
> {
> private:
> typedef mpl::arg<1> n1;
> typedef aux::replace_unnamed_arg< T1,n1 > r1;
> typedef typename r1::type a1;
> typedef typename r1::next n2;
> typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
>
> typedef aux::replace_unnamed_arg< T2,n2 > r2;
> typedef typename r2::type a2;
> typedef typename r2::next n3;
> typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
>
> typedef aux::replace_unnamed_arg< T3,n3 > r3;
> typedef typename r3::type a3;
> typedef typename r3::next n4;
> typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
>
> typedef typename eval_if<
> typename t1::type
> , t2, t3
> >::type f_;
>
> public:
> typedef typename f_::type type;
> };
>};
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 51 "/usr/include/boost/mpl/bind.hpp" 2 3 4
># 19 "/usr/include/boost/mpl/lambda.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 3 4
># 1 "/usr/include/boost/mpl/bind_fwd.hpp" 1 3 4
># 24 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/quote.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/quote.hpp" 3 4
># 1 "/usr/include/boost/mpl/void.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/void.hpp" 3 4
>namespace mpl_ {
>
>
>
>
>
>struct void_ { typedef void_ type; };
>
>}
>
>namespace boost { namespace mpl {
>
>template< typename T >
>struct is_void_
> : false_
>{
>
>
>
>};
>
>template<>
>struct is_void_<void_>
> : true_
>{
>
>
>
>};
>
>template< typename T >
>struct is_not_void_
> : true_
>{
>
>
>
>};
>
>template<>
>struct is_not_void_<void_>
> : false_
>{
>
>
>
>};
>
>template<> struct is_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_void_< T1 > { }; }; template< typename Tag > struct lambda< is_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_void_< na > result_; typedef is_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_void_< na > > : int_<-1> { }; }
>template<> struct is_not_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_not_void_< T1 > { }; }; template< typename Tag > struct lambda< is_not_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_not_void_< na > result_; typedef is_not_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_not_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_not_void_< na > > : int_<-1> { }; }
>
>}}
># 23 "/usr/include/boost/mpl/quote.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/has_type.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/has_type.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper const volatile* , boost::mpl::aux::type_wrapper<typename U::type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
>}}}
># 24 "/usr/include/boost/mpl/quote.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/aux_/config/bcc.hpp" 1 3 4
># 27 "/usr/include/boost/mpl/quote.hpp" 2 3 4
># 45 "/usr/include/boost/mpl/quote.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename T, bool has_type_ >
>struct quote_impl
>{
> typedef typename T::type type;
>};
>
>template< typename T >
>struct quote_impl< T,false >
>{
> typedef T type;
>};
>
>template<
> template< typename P1 > class F
> , typename Tag = void_
> >
>struct quote1
>{
> template< typename U1 > struct apply
>
> : quote_impl<
> F<U1>
> , aux::has_type< F<U1> >::value
> >
>
> {
> };
>};
>
>template<
> template< typename P1, typename P2 > class F
> , typename Tag = void_
> >
>struct quote2
>{
> template< typename U1, typename U2 > struct apply
>
> : quote_impl<
> F< U1,U2 >
> , aux::has_type< F< U1,U2 > >::value
> >
>
> {
> };
>};
>
>template<
> template< typename P1, typename P2, typename P3 > class F
> , typename Tag = void_
> >
>struct quote3
>{
> template< typename U1, typename U2, typename U3 > struct apply
>
> : quote_impl<
> F< U1,U2,U3 >
> , aux::has_type< F< U1,U2,U3 > >::value
> >
>
> {
> };
>};
>
>template<
> template< typename P1, typename P2, typename P3, typename P4 > class F
> , typename Tag = void_
> >
>struct quote4
>{
> template<
> typename U1, typename U2, typename U3, typename U4
> >
> struct apply
>
> : quote_impl<
> F< U1,U2,U3,U4 >
> , aux::has_type< F< U1,U2,U3,U4 > >::value
> >
>
> {
> };
>};
>
>template<
> template<
> typename P1, typename P2, typename P3, typename P4
> , typename P5
> >
> class F
> , typename Tag = void_
> >
>struct quote5
>{
> template<
> typename U1, typename U2, typename U3, typename U4
> , typename U5
> >
> struct apply
>
> : quote_impl<
> F< U1,U2,U3,U4,U5 >
> , aux::has_type< F< U1,U2,U3,U4,U5 > >::value
> >
>
> {
> };
>};
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 46 "/usr/include/boost/mpl/quote.hpp" 2 3 4
># 26 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
># 27 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/aux_/template_arity.hpp" 1 3 4
># 43 "/usr/include/boost/mpl/aux_/template_arity.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>template< int N > struct arity_tag
>{
> typedef char (&type)[N + 1];
>};
>
>template<
> int C1, int C2, int C3, int C4, int C5, int C6
> >
>struct max_arity
>{
> static const int value = ( C6 > 0 ? C6 : ( C5 > 0 ? C5 : ( C4 > 0 ? C4 : ( C3 > 0 ? C3 : ( C2 > 0 ? C2 : ( C1 > 0 ? C1 : -1 ) ) ) ) ) )
>
> ;
>};
>
>arity_tag<0>::type arity_helper(...);
>
>template<
> template< typename P1 > class F
> , typename T1
> >
>typename arity_tag<1>::type
>arity_helper(type_wrapper< F<T1> >, arity_tag<1>);
>
>template<
> template< typename P1, typename P2 > class F
> , typename T1, typename T2
> >
>typename arity_tag<2>::type
>arity_helper(type_wrapper< F< T1,T2 > >, arity_tag<2>);
>
>template<
> template< typename P1, typename P2, typename P3 > class F
> , typename T1, typename T2, typename T3
> >
>typename arity_tag<3>::type
>arity_helper(type_wrapper< F< T1,T2,T3 > >, arity_tag<3>);
>
>template<
> template< typename P1, typename P2, typename P3, typename P4 > class F
> , typename T1, typename T2, typename T3, typename T4
> >
>typename arity_tag<4>::type
>arity_helper(type_wrapper< F< T1,T2,T3,T4 > >, arity_tag<4>);
>
>template<
> template<
> typename P1, typename P2, typename P3, typename P4
> , typename P5
> >
> class F
> , typename T1, typename T2, typename T3, typename T4, typename T5
> >
>typename arity_tag<5>::type
>arity_helper(type_wrapper< F< T1,T2,T3,T4,T5 > >, arity_tag<5>);
>
>template<
> template<
> typename P1, typename P2, typename P3, typename P4
> , typename P5, typename P6
> >
> class F
> , typename T1, typename T2, typename T3, typename T4, typename T5
> , typename T6
> >
>typename arity_tag<6>::type
>arity_helper(type_wrapper< F< T1,T2,T3,T4,T5,T6 > >, arity_tag<6>);
>template< typename F, int N >
>struct template_arity_impl
>{
> static const int value = sizeof(::boost::mpl::aux::arity_helper(type_wrapper<F>(), arity_tag<N>())) - 1
>
> ;
>};
>
>template< typename F >
>struct template_arity
>{
> static const int value = ( max_arity< template_arity_impl< F,1 >::value, template_arity_impl< F,2 >::value, template_arity_impl< F,3 >::value, template_arity_impl< F,4 >::value, template_arity_impl< F,5 >::value, template_arity_impl< F,6 >::value >::value )
>
> ;
> typedef mpl::int_<value> type;
>};
>
>}}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 44 "/usr/include/boost/mpl/aux_/template_arity.hpp" 2 3 4
># 30 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
># 44 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp" 3 4
>namespace boost { namespace mpl {
>
>namespace aux {
>
>template<
> bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false
> , bool C5 = false
> >
>struct lambda_or
> : true_
>{
>};
>
>template<>
>struct lambda_or< false,false,false,false,false >
> : false_
>{
>};
>
>}
>
>template<
> typename T
> , typename Tag
> , typename Arity
> >
>struct lambda
>{
> typedef false_ is_le;
> typedef T result_;
> typedef T type;
>};
>
>template<
> typename T
> >
>struct is_lambda_expression
> : lambda<T>::is_le
>{
>};
>
>template< int N, typename Tag >
>struct lambda< arg<N>,Tag, int_< -1 > >
>{
> typedef true_ is_le;
> typedef mpl::arg<N> result_;
> typedef mpl::protect<result_> type;
>};
>
>template<
> typename F
> , typename Tag
> >
>struct lambda<
> bind0<F>
> , Tag
> , int_<1>
> >
>{
> typedef false_ is_le;
> typedef bind0<
> F
> > result_;
>
> typedef result_ type;
>};
>
>namespace aux {
>
>template<
> typename IsLE, typename Tag
> , template< typename P1 > class F
> , typename L1
> >
>struct le_result1
>{
> typedef F<
> typename L1::type
> > result_;
>
> typedef result_ type;
>};
>
>template<
> typename Tag
> , template< typename P1 > class F
> , typename L1
> >
>struct le_result1< true_,Tag,F,L1 >
>{
> typedef bind1<
> quote1< F,Tag >
> , typename L1::result_
> > result_;
>
> typedef mpl::protect<result_> type;
>};
>
>}
>
>template<
> template< typename P1 > class F
> , typename T1
> , typename Tag
> >
>struct lambda<
> F<T1>
> , Tag
> , int_<1>
> >
>{
> typedef lambda< T1,Tag > l1;
> typedef typename l1::is_le is_le1;
> typedef typename aux::lambda_or<
> is_le1::value
> >::type is_le;
>
> typedef aux::le_result1<
> is_le, Tag, F, l1
> > le_result_;
>
> typedef typename le_result_::result_ result_;
> typedef typename le_result_::type type;
>};
>
>template<
> typename F, typename T1
> , typename Tag
> >
>struct lambda<
> bind1< F,T1 >
> , Tag
> , int_<2>
> >
>{
> typedef false_ is_le;
> typedef bind1<
> F
> , T1
> > result_;
>
> typedef result_ type;
>};
>
>namespace aux {
>
>template<
> typename IsLE, typename Tag
> , template< typename P1, typename P2 > class F
> , typename L1, typename L2
> >
>struct le_result2
>{
> typedef F<
> typename L1::type, typename L2::type
> > result_;
>
> typedef result_ type;
>};
>
>template<
> typename Tag
> , template< typename P1, typename P2 > class F
> , typename L1, typename L2
> >
>struct le_result2< true_,Tag,F,L1,L2 >
>{
> typedef bind2<
> quote2< F,Tag >
> , typename L1::result_, typename L2::result_
> > result_;
>
> typedef mpl::protect<result_> type;
>};
>
>}
>
>template<
> template< typename P1, typename P2 > class F
> , typename T1, typename T2
> , typename Tag
> >
>struct lambda<
> F< T1,T2 >
> , Tag
> , int_<2>
> >
>{
> typedef lambda< T1,Tag > l1;
> typedef lambda< T2,Tag > l2;
>
> typedef typename l1::is_le is_le1;
> typedef typename l2::is_le is_le2;
>
>
> typedef typename aux::lambda_or<
> is_le1::value, is_le2::value
> >::type is_le;
>
> typedef aux::le_result2<
> is_le, Tag, F, l1, l2
> > le_result_;
>
> typedef typename le_result_::result_ result_;
> typedef typename le_result_::type type;
>};
>
>template<
> typename F, typename T1, typename T2
> , typename Tag
> >
>struct lambda<
> bind2< F,T1,T2 >
> , Tag
> , int_<3>
> >
>{
> typedef false_ is_le;
> typedef bind2<
> F
> , T1, T2
> > result_;
>
> typedef result_ type;
>};
>
>namespace aux {
>
>template<
> typename IsLE, typename Tag
> , template< typename P1, typename P2, typename P3 > class F
> , typename L1, typename L2, typename L3
> >
>struct le_result3
>{
> typedef F<
> typename L1::type, typename L2::type, typename L3::type
> > result_;
>
> typedef result_ type;
>};
>
>template<
> typename Tag
> , template< typename P1, typename P2, typename P3 > class F
> , typename L1, typename L2, typename L3
> >
>struct le_result3< true_,Tag,F,L1,L2,L3 >
>{
> typedef bind3<
> quote3< F,Tag >
> , typename L1::result_, typename L2::result_, typename L3::result_
> > result_;
>
> typedef mpl::protect<result_> type;
>};
>
>}
>
>template<
> template< typename P1, typename P2, typename P3 > class F
> , typename T1, typename T2, typename T3
> , typename Tag
> >
>struct lambda<
> F< T1,T2,T3 >
> , Tag
> , int_<3>
> >
>{
> typedef lambda< T1,Tag > l1;
> typedef lambda< T2,Tag > l2;
> typedef lambda< T3,Tag > l3;
>
> typedef typename l1::is_le is_le1;
> typedef typename l2::is_le is_le2;
> typedef typename l3::is_le is_le3;
>
>
> typedef typename aux::lambda_or<
> is_le1::value, is_le2::value, is_le3::value
> >::type is_le;
>
> typedef aux::le_result3<
> is_le, Tag, F, l1, l2, l3
> > le_result_;
>
> typedef typename le_result_::result_ result_;
> typedef typename le_result_::type type;
>};
>
>template<
> typename F, typename T1, typename T2, typename T3
> , typename Tag
> >
>struct lambda<
> bind3< F,T1,T2,T3 >
> , Tag
> , int_<4>
> >
>{
> typedef false_ is_le;
> typedef bind3<
> F
> , T1, T2, T3
> > result_;
>
> typedef result_ type;
>};
>
>namespace aux {
>
>template<
> typename IsLE, typename Tag
> , template< typename P1, typename P2, typename P3, typename P4 > class F
> , typename L1, typename L2, typename L3, typename L4
> >
>struct le_result4
>{
> typedef F<
> typename L1::type, typename L2::type, typename L3::type
> , typename L4::type
> > result_;
>
> typedef result_ type;
>};
>
>template<
> typename Tag
> , template< typename P1, typename P2, typename P3, typename P4 > class F
> , typename L1, typename L2, typename L3, typename L4
> >
>struct le_result4< true_,Tag,F,L1,L2,L3,L4 >
>{
> typedef bind4<
> quote4< F,Tag >
> , typename L1::result_, typename L2::result_, typename L3::result_
> , typename L4::result_
> > result_;
>
> typedef mpl::protect<result_> type;
>};
>
>}
>
>template<
> template< typename P1, typename P2, typename P3, typename P4 > class F
> , typename T1, typename T2, typename T3, typename T4
> , typename Tag
> >
>struct lambda<
> F< T1,T2,T3,T4 >
> , Tag
> , int_<4>
> >
>{
> typedef lambda< T1,Tag > l1;
> typedef lambda< T2,Tag > l2;
> typedef lambda< T3,Tag > l3;
> typedef lambda< T4,Tag > l4;
>
> typedef typename l1::is_le is_le1;
> typedef typename l2::is_le is_le2;
> typedef typename l3::is_le is_le3;
> typedef typename l4::is_le is_le4;
>
>
> typedef typename aux::lambda_or<
> is_le1::value, is_le2::value, is_le3::value, is_le4::value
> >::type is_le;
>
> typedef aux::le_result4<
> is_le, Tag, F, l1, l2, l3, l4
> > le_result_;
>
> typedef typename le_result_::result_ result_;
> typedef typename le_result_::type type;
>};
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> , typename Tag
> >
>struct lambda<
> bind4< F,T1,T2,T3,T4 >
> , Tag
> , int_<5>
> >
>{
> typedef false_ is_le;
> typedef bind4<
> F
> , T1, T2, T3, T4
> > result_;
>
> typedef result_ type;
>};
>
>namespace aux {
>
>template<
> typename IsLE, typename Tag
> , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
> , typename L1, typename L2, typename L3, typename L4, typename L5
> >
>struct le_result5
>{
> typedef F<
> typename L1::type, typename L2::type, typename L3::type
> , typename L4::type, typename L5::type
> > result_;
>
> typedef result_ type;
>};
>
>template<
> typename Tag
> , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
> , typename L1, typename L2, typename L3, typename L4, typename L5
> >
>struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 >
>{
> typedef bind5<
> quote5< F,Tag >
> , typename L1::result_, typename L2::result_, typename L3::result_
> , typename L4::result_, typename L5::result_
> > result_;
>
> typedef mpl::protect<result_> type;
>};
>
>}
>
>template<
> template<
> typename P1, typename P2, typename P3, typename P4
> , typename P5
> >
> class F
> , typename T1, typename T2, typename T3, typename T4, typename T5
> , typename Tag
> >
>struct lambda<
> F< T1,T2,T3,T4,T5 >
> , Tag
> , int_<5>
> >
>{
> typedef lambda< T1,Tag > l1;
> typedef lambda< T2,Tag > l2;
> typedef lambda< T3,Tag > l3;
> typedef lambda< T4,Tag > l4;
> typedef lambda< T5,Tag > l5;
>
> typedef typename l1::is_le is_le1;
> typedef typename l2::is_le is_le2;
> typedef typename l3::is_le is_le3;
> typedef typename l4::is_le is_le4;
> typedef typename l5::is_le is_le5;
>
>
> typedef typename aux::lambda_or<
> is_le1::value, is_le2::value, is_le3::value, is_le4::value
> , is_le5::value
> >::type is_le;
>
> typedef aux::le_result5<
> is_le, Tag, F, l1, l2, l3, l4, l5
> > le_result_;
>
> typedef typename le_result_::result_ result_;
> typedef typename le_result_::type type;
>};
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> , typename T5
> , typename Tag
> >
>struct lambda<
> bind5< F,T1,T2,T3,T4,T5 >
> , Tag
> , int_<6>
> >
>{
> typedef false_ is_le;
> typedef bind5<
> F
> , T1, T2, T3, T4, T5
> > result_;
>
> typedef result_ type;
>};
>
>
>template< typename T, typename Tag >
>struct lambda< mpl::protect<T>,Tag, int_<1> >
>{
> typedef false_ is_le;
> typedef mpl::protect<T> result_;
> typedef result_ type;
>};
>
>
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> , typename T5
> , typename Tag
> >
>struct lambda<
> bind< F,T1,T2,T3,T4,T5 >
> , Tag
> , int_<6>
> >
>{
> typedef false_ is_le;
> typedef bind< F,T1,T2,T3,T4,T5 > result_;
> typedef result_ type;
>};
>
>template<
> typename F
> , typename Tag1
> , typename Tag2
> , typename Arity
> >
>struct lambda<
> lambda< F,Tag1,Arity >
> , Tag2
> , int_<3>
> >
>{
> typedef lambda< F,Tag2 > l1;
> typedef lambda< Tag1,Tag2 > l2;
> typedef typename l1::is_le is_le;
> typedef bind1< quote1<aux::template_arity>, typename l1::result_ > arity_;
> typedef lambda< typename if_< is_le,arity_,Arity >::type, Tag2 > l3;
> typedef aux::le_result3<is_le, Tag2, mpl::lambda, l1, l2, l3> le_result_;
> typedef typename le_result_::result_ result_;
> typedef typename le_result_::type type;
>};
>
>template<> struct lambda< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : lambda< T1 , T2 > { }; }; template< typename Tag > struct lambda< lambda< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef lambda< na , na > result_; typedef lambda< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< lambda< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< lambda< na , na > > : int_<-1> { }; }
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 45 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
># 23 "/usr/include/boost/mpl/lambda.hpp" 2 3 4
># 26 "/usr/include/boost/mpl/apply.hpp" 2 3 4
># 36 "/usr/include/boost/mpl/apply.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename F
> >
>struct apply0
>
> : apply_wrap0<
> typename lambda<F>::type
>
> >
>{
> 
>
>
>
>
>};
>
>template<
> typename F
> >
>struct apply< F,na,na,na,na,na >
> : apply0<F>
>{
>};
>
>template<
> typename F, typename T1
> >
>struct apply1
>
> : apply_wrap1<
> typename lambda<F>::type
> , T1
> >
>{
> 
>
>
>
>
>};
>
>template<
> typename F, typename T1
> >
>struct apply< F,T1,na,na,na,na >
> : apply1< F,T1 >
>{
>};
>
>template<
> typename F, typename T1, typename T2
> >
>struct apply2
>
> : apply_wrap2<
> typename lambda<F>::type
> , T1, T2
> >
>{
> 
>
>
>
>
>};
>
>template<
> typename F, typename T1, typename T2
> >
>struct apply< F,T1,T2,na,na,na >
> : apply2< F,T1,T2 >
>{
>};
>
>template<
> typename F, typename T1, typename T2, typename T3
> >
>struct apply3
>
> : apply_wrap3<
> typename lambda<F>::type
> , T1, T2, T3
> >
>{
> 
>
>
>
>
>};
>
>template<
> typename F, typename T1, typename T2, typename T3
> >
>struct apply< F,T1,T2,T3,na,na >
> : apply3< F,T1,T2,T3 >
>{
>};
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> >
>struct apply4
>
> : apply_wrap4<
> typename lambda<F>::type
> , T1, T2, T3, T4
> >
>{
> 
>
>
>
>
>};
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> >
>struct apply< F,T1,T2,T3,T4,na >
> : apply4< F,T1,T2,T3,T4 >
>{
>};
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> , typename T5
> >
>struct apply5
>
> : apply_wrap5<
> typename lambda<F>::type
> , T1, T2, T3, T4, T5
> >
>{
> 
>
>
>
>
>};
>
>
>
>template<
> typename F, typename T1, typename T2, typename T3, typename T4
> , typename T5
> >
>struct apply
> : apply5< F,T1,T2,T3,T4,T5 >
>{
>};
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 37 "/usr/include/boost/mpl/apply.hpp" 2 3 4
># 35 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
># 38 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
>
>namespace boost
>{
>
>
> template <class I, class V, class TC, class R, class D> class iterator_facade;
>
> namespace detail
> {
>
>
>
> struct always_bool2
> {
> template <class T, class U>
> struct apply
> {
> typedef bool type;
> };
> };
>
>
>
>
> template <
> class Facade1
> , class Facade2
> , class Return
> >
> struct enable_if_interoperable
># 80 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
> : ::boost::iterators::enable_if<
> mpl::or_<
> is_convertible<Facade1, Facade2>
> , is_convertible<Facade2, Facade1>
> >
> , Return
> >
> {};
>
>
>
>
>
>
> template <
> class ValueParam
> , class CategoryOrTraversal
> , class Reference
> , class Difference
> >
> struct iterator_facade_types
> {
> typedef typename facade_iterator_category<
> CategoryOrTraversal, ValueParam, Reference
> >::type iterator_category;
>
> typedef typename remove_const<ValueParam>::type value_type;
>
>
> typedef typename mpl::eval_if<
> boost::detail::iterator_writability_disabled<ValueParam,Reference>
> , add_pointer<const value_type>
> , add_pointer<value_type>
> >::type pointer;
># 131 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
> };
>
>
>
>
>
>
>
> template <class Iterator>
> class postfix_increment_proxy
> {
> typedef typename iterator_value<Iterator>::type value_type;
> public:
> explicit postfix_increment_proxy(Iterator const& x)
> : stored_value(*x)
> {}
>
>
>
>
>
> value_type&
> operator*() const
> {
> return this->stored_value;
> }
> private:
> mutable value_type stored_value;
> };
>
>
>
>
>
> template <class Iterator>
> class writable_postfix_increment_proxy
> {
> typedef typename iterator_value<Iterator>::type value_type;
> public:
> explicit writable_postfix_increment_proxy(Iterator const& x)
> : stored_value(*x)
> , stored_iterator(x)
> {}
>
>
>
>
>
> writable_postfix_increment_proxy const&
> operator*() const
> {
> return *this;
> }
>
>
> operator value_type&() const
> {
> return stored_value;
> }
>
>
> template <class T>
> T const& operator=(T const& x) const
> {
> *this->stored_iterator = x;
> return x;
> }
>
>
> template <class T>
> T& operator=(T& x) const
> {
> *this->stored_iterator = x;
> return x;
> }
>
>
> operator Iterator const&() const
> {
> return stored_iterator;
> }
>
> private:
> mutable value_type stored_value;
> Iterator stored_iterator;
> };
># 245 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
> template <class Reference, class Value>
> struct is_non_proxy_reference
> : is_convertible<
> typename remove_reference<Reference>::type
> const volatile*
> , Value const volatile*
> >
> {};
># 270 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
> template <class Iterator, class Value, class Reference, class CategoryOrTraversal>
> struct postfix_increment_result
> : mpl::eval_if<
> mpl::and_<
>
> is_convertible<Reference,Value const&>
>
>
>
> , mpl::not_<
> is_convertible<
> typename iterator_category_to_traversal<CategoryOrTraversal>::type
> , forward_traversal_tag
> >
> >
> >
> , mpl::if_<
> is_non_proxy_reference<Reference,Value>
> , postfix_increment_proxy<Iterator>
> , writable_postfix_increment_proxy<Iterator>
> >
> , mpl::identity<Iterator>
> >
> {};
>
>
>
>
>
> template <class Reference, class Pointer>
> struct operator_arrow_dispatch
> {
> struct proxy
> {
> explicit proxy(Reference const & x) : m_ref(x) {}
> Reference* operator->() { return boost::addressof(m_ref); }
>
>
> operator Reference*() { return boost::addressof(m_ref); }
> Reference m_ref;
> };
> typedef proxy result_type;
> static result_type apply(Reference const & x)
> {
> return result_type(x);
> }
> };
>
> template <class T, class Pointer>
> struct operator_arrow_dispatch<T&, Pointer>
> {
> typedef Pointer result_type;
> static result_type apply(T& x)
> {
> return boost::addressof(x);
> }
> };
># 340 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
> template <class Iterator>
> class operator_brackets_proxy
> {
>
>
> typedef typename Iterator::reference reference;
> typedef typename Iterator::value_type value_type;
>
> public:
> operator_brackets_proxy(Iterator const& iter)
> : m_iter(iter)
> {}
>
> operator reference() const
> {
> return *m_iter;
> }
>
> operator_brackets_proxy& operator=(value_type const& val)
> {
> *m_iter = val;
> return *this;
> }
>
> private:
> Iterator m_iter;
> };
>
>
>
> template <class ValueType, class Reference>
> struct use_operator_brackets_proxy
> : mpl::not_<
> mpl::and_<
>
>
> boost::is_POD<ValueType>
> , iterator_writability_disabled<ValueType,Reference>
> >
> >
> {};
>
> template <class Iterator, class Value, class Reference>
> struct operator_brackets_result
> {
> typedef typename mpl::if_<
> use_operator_brackets_proxy<Value,Reference>
> , operator_brackets_proxy<Iterator>
> , Value
> >::type type;
> };
>
> template <class Iterator>
> operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::true_)
> {
> return operator_brackets_proxy<Iterator>(iter);
> }
>
> template <class Iterator>
> typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_)
> {
> return *iter;
> }
>
> struct choose_difference_type
> {
> template <class I1, class I2>
> struct apply
> :
># 418 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
> mpl::eval_if<
> is_convertible<I2,I1>
> , iterator_difference<I1>
> , iterator_difference<I2>
> >
>
> {};
>
> };
> }
># 469 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
> class iterator_core_access
> {
>
>
>
>
>
>
> template <class I, class V, class TC, class R, class D> friend class iterator_facade;
>
>
>
>
> template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator ==( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
> template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator !=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
>
> template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
> template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
> template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
> template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
>
>
> template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::choose_difference_type,Derived1,Derived2>::type >::type operator -( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
>
> ;
>
> template <class Derived, class V, class TC, class R, class D> friend inline Derived operator+ (iterator_facade<Derived, V, TC, R, D> const& , typename Derived::difference_type)
>
>
>
>
> ;
>
> template <class Derived, class V, class TC, class R, class D> friend inline Derived operator+ (typename Derived::difference_type , iterator_facade<Derived, V, TC, R, D> const&)
>
>
>
>
> ;
>
>
>
> template <class Facade>
> static typename Facade::reference dereference(Facade const& f)
> {
> return f.dereference();
> }
>
> template <class Facade>
> static void increment(Facade& f)
> {
> f.increment();
> }
>
> template <class Facade>
> static void decrement(Facade& f)
> {
> f.decrement();
> }
>
> template <class Facade1, class Facade2>
> static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
> {
> return f1.equal(f2);
> }
>
> template <class Facade1, class Facade2>
> static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
> {
> return f2.equal(f1);
> }
>
> template <class Facade>
> static void advance(Facade& f, typename Facade::difference_type n)
> {
> f.advance(n);
> }
>
> template <class Facade1, class Facade2>
> static typename Facade1::difference_type distance_from(
> Facade1 const& f1, Facade2 const& f2, mpl::true_)
> {
> return -f1.distance_to(f2);
> }
>
> template <class Facade1, class Facade2>
> static typename Facade2::difference_type distance_from(
> Facade1 const& f1, Facade2 const& f2, mpl::false_)
> {
> return f2.distance_to(f1);
> }
>
>
>
>
> template <class I, class V, class TC, class R, class D>
> static I& derived(iterator_facade<I,V,TC,R,D>& facade)
> {
> return *static_cast<I*>(&facade);
> }
>
> template <class I, class V, class TC, class R, class D>
> static I const& derived(iterator_facade<I,V,TC,R,D> const& facade)
> {
> return *static_cast(&facade);
> }
>
> private:
>
> iterator_core_access();
> };
>
>
>
>
>
> template <
> class Derived
> , class Value
> , class CategoryOrTraversal
> , class Reference = Value&
> , class Difference = std::ptrdiff_t
> >
> class iterator_facade
>
>
>
>
>
>
> {
> private:
>
>
>
> Derived& derived()
> {
> return *static_cast<Derived*>(this);
> }
>
> Derived const& derived() const
> {
> return *static_cast<Derived const*>(this);
> }
>
> typedef boost::detail::iterator_facade_types<
> Value, CategoryOrTraversal, Reference, Difference
> > associated_types;
>
> typedef boost::detail::operator_arrow_dispatch<
> Reference
> , typename associated_types::pointer
> > operator_arrow_dispatch_;
>
> protected:
>
> typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_;
>
> public:
>
> typedef typename associated_types::value_type value_type;
> typedef Reference reference;
> typedef Difference difference_type;
>
> typedef typename operator_arrow_dispatch_::result_type pointer;
>
> typedef typename associated_types::iterator_category iterator_category;
>
> reference operator*() const
> {
> return iterator_core_access::dereference(this->derived());
> }
>
> pointer operator->() const
> {
> return operator_arrow_dispatch_::apply(*this->derived());
> }
>
> typename boost::detail::operator_brackets_result<Derived,Value,reference>::type
> operator[](difference_type n) const
> {
> typedef boost::detail::use_operator_brackets_proxy<Value,Reference> use_proxy;
>
> return boost::detail::make_operator_brackets_result<Derived>(
> this->derived() + n
> , use_proxy()
> );
> }
>
> Derived& operator++()
> {
> iterator_core_access::increment(this->derived());
> return this->derived();
> }
># 675 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
> Derived& operator--()
> {
> iterator_core_access::decrement(this->derived());
> return this->derived();
> }
>
> Derived operator--(int)
> {
> Derived tmp(this->derived());
> --*this;
> return tmp;
> }
>
> Derived& operator+=(difference_type n)
> {
> iterator_core_access::advance(this->derived(), n);
> return this->derived();
> }
>
> Derived& operator-=(difference_type n)
> {
> iterator_core_access::advance(this->derived(), -n);
> return this->derived();
> }
>
> Derived operator-(difference_type x) const
> {
> Derived result(this->derived());
> return result -= x;
> }
># 717 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
> };
>
>
> template <class I, class V, class TC, class R, class D>
> inline typename boost::detail::postfix_increment_result<I,V,R,TC>::type
> operator++(
> iterator_facade<I,V,TC,R,D>& i
> , int
> )
> {
> typename boost::detail::postfix_increment_result<I,V,R,TC>::type
> tmp(*static_cast<I*>(&i));
>
> ++i;
>
> return tmp;
> }
># 832 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
> template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator ==( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value ), "( is_interoperable< Derived1, Derived2 >::value )"); return iterator_core_access::equal( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
> template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator !=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value ), "( is_interoperable< Derived1, Derived2 >::value )"); return ! iterator_core_access::equal( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
>
> template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value ), "( is_interoperable< Derived1, Derived2 >::value )"); return 0 > iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
> template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value ), "( is_interoperable< Derived1, Derived2 >::value )"); return 0 < iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
> template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value ), "( is_interoperable< Derived1, Derived2 >::value )"); return 0 >= iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
> template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value ), "( is_interoperable< Derived1, Derived2 >::value )"); return 0 <= iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
>
>
>
> template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::choose_difference_type,Derived1,Derived2>::type >::type operator -( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value ), "( is_interoperable< Derived1, Derived2 >::value )"); return iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
># 858 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
>template <class Derived, class V, class TC, class R, class D> inline Derived operator+ ( iterator_facade<Derived, V, TC, R, D> const& i , typename Derived::difference_type n ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }
>
>
>
>
>template <class Derived, class V, class TC, class R, class D> inline Derived operator+ ( typename Derived::difference_type n , iterator_facade<Derived, V, TC, R, D> const& i ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }
>
>
>
>
>
>
>}
>
># 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
># 873 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
># 16 "/usr/include/boost/iterator/iterator_adaptor.hpp" 2 3 4
># 30 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
># 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
># 31 "/usr/include/boost/iterator/iterator_adaptor.hpp" 2 3 4
>
>
>
>namespace boost
>{
>
>
>
> struct use_default;
>
>
>
>
>
> template<class To>
> struct is_convertible<use_default,To>
> : mpl::false_ {};
>
>
> namespace detail
> {
># 60 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
> struct enable_type;
> }
># 142 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
> template<typename From, typename To>
> struct enable_if_convertible
> : iterators::enable_if<
> is_convertible<From, To>
> , boost::detail::enable_type
> >
> {};
>
>
>
>
>
>
> namespace detail
> {
>
>
> template <class T, class DefaultNullaryFn>
> struct ia_dflt_help
> : mpl::eval_if<
> is_same<T, use_default>
> , DefaultNullaryFn
> , mpl::identity<T>
> >
> {
> };
>
>
>
> template <
> class Derived
> , class Base
> , class Value
> , class Traversal
> , class Reference
> , class Difference
> >
> struct iterator_adaptor_base
> {
> typedef iterator_facade<
> Derived
>
>
> , typename boost::detail::ia_dflt_help<
> Value
> , mpl::eval_if<
> is_same<Reference,use_default>
> , iterator_value<Base>
> , remove_reference<Reference>
> >
> >::type
>
>
>
>
>
>
> , typename boost::detail::ia_dflt_help<
> Traversal
> , iterator_traversal<Base>
> >::type
>
> , typename boost::detail::ia_dflt_help<
> Reference
> , mpl::eval_if<
> is_same<Value,use_default>
> , iterator_reference<Base>
> , add_reference<Value>
> >
> >::type
>
> , typename boost::detail::ia_dflt_help<
> Difference, iterator_difference<Base>
> >::type
> >
> type;
> };
>
>
> template <class Tr1, class Tr2>
> inline void iterator_adaptor_assert_traversal ()
> {
> static_assert((is_convertible<Tr1, Tr2>::value), "(is_convertible<Tr1, Tr2>::value)");
> }
> }
># 253 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
> template <
> class Derived
> , class Base
> , class Value = use_default
> , class Traversal = use_default
> , class Reference = use_default
> , class Difference = use_default
> >
> class iterator_adaptor
> : public boost::detail::iterator_adaptor_base<
> Derived, Base, Value, Traversal, Reference, Difference
> >::type
> {
> friend class iterator_core_access;
>
> protected:
> typedef typename boost::detail::iterator_adaptor_base<
> Derived, Base, Value, Traversal, Reference, Difference
> >::type super_t;
> public:
> iterator_adaptor() {}
>
> explicit iterator_adaptor(Base const &iter)
> : m_iterator(iter)
> {
> }
>
> typedef Base base_type;
>
> Base const& base() const
> { return m_iterator; }
>
> protected:
>
> typedef iterator_adaptor<Derived,Base,Value,Traversal,Reference,Difference> iterator_adaptor_;
>
>
>
>
> Base const& base_reference() const
> { return m_iterator; }
>
> Base& base_reference()
> { return m_iterator; }
>
> private:
>
>
>
>
>
>
> typename super_t::reference dereference() const
> { return *m_iterator; }
>
> template <
> class OtherDerived, class OtherIterator, class V, class C, class R, class D
> >
> bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const
> {
>
>
>
>
> return m_iterator == x.base();
> }
>
> typedef typename iterator_category_to_traversal<
> typename super_t::iterator_category
> >::type my_traversal;
>
>
>
>
> void advance(typename super_t::difference_type n)
> {
> boost::detail::iterator_adaptor_assert_traversal<my_traversal, random_access_traversal_tag>();
> m_iterator += n;
> }
>
> void increment() { ++m_iterator; }
>
> void decrement()
> {
> boost::detail::iterator_adaptor_assert_traversal<my_traversal, bidirectional_traversal_tag>();
> --m_iterator;
> }
>
> template <
> class OtherDerived, class OtherIterator, class V, class C, class R, class D
> >
> typename super_t::difference_type distance_to(
> iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const
> {
> boost::detail::iterator_adaptor_assert_traversal<my_traversal, random_access_traversal_tag>();
>
>
>
>
> return y.base() - m_iterator;
> }
>
>
>
> private:
> Base m_iterator;
> };
>
>}
>
># 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
># 364 "/usr/include/boost/iterator/iterator_adaptor.hpp" 2 3 4
># 13 "/usr/include/boost/iterator/reverse_iterator.hpp" 2 3 4
>
>namespace boost
>{
>
>
>
>
> template <class Iterator>
> class reverse_iterator
> : public iterator_adaptor< reverse_iterator<Iterator>, Iterator >
> {
> typedef iterator_adaptor< reverse_iterator<Iterator>, Iterator > super_t;
>
> friend class iterator_core_access;
>
> public:
> reverse_iterator() {}
>
> explicit reverse_iterator(Iterator x)
> : super_t(x) {}
>
> template<class OtherIterator>
> reverse_iterator(
> reverse_iterator<OtherIterator> const& r
> , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
> )
> : super_t(r.base())
> {}
>
> private:
> typename super_t::reference dereference() const { return *boost::prior(this->base()); }
>
> void increment() { --this->base_reference(); }
> void decrement() { ++this->base_reference(); }
>
> void advance(typename super_t::difference_type n)
> {
> this->base_reference() += -n;
> }
>
> template <class OtherIterator>
> typename super_t::difference_type
> distance_to(reverse_iterator<OtherIterator> const& y) const
> {
> return this->base_reference() - y.base();
> }
> };
>
> template <class BidirectionalIterator>
> reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
> {
> return reverse_iterator<BidirectionalIterator>(x);
> }
>
>}
># 20 "/usr/include/boost/circular_buffer/base.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/is_stateless.hpp" 1 3 4
># 12 "/usr/include/boost/type_traits/is_stateless.hpp" 3 4
># 1 "/usr/include/boost/type_traits/has_trivial_constructor.hpp" 1 3 4
># 18 "/usr/include/boost/type_traits/has_trivial_constructor.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 19 "/usr/include/boost/type_traits/has_trivial_constructor.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
>
>template <typename T>
>struct has_trivial_ctor_impl
>{
>
> static const bool value = (::boost::type_traits::ice_or< ::boost::is_pod<T>::value, ((__has_trivial_constructor(T) ) && ! ::boost::is_volatile<T>::value) >::value)
>
>
>
> ;
>
>
>
>
>
>
>
>};
>
>}
>
>template< typename T > struct has_trivial_constructor : public ::boost::integral_constant<bool,::boost::detail::has_trivial_ctor_impl<T>::value> { public: };
>template< typename T > struct has_trivial_default_constructor : public ::boost::integral_constant<bool,::boost::detail::has_trivial_ctor_impl<T>::value> { public: };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 50 "/usr/include/boost/type_traits/has_trivial_constructor.hpp" 2 3 4
># 13 "/usr/include/boost/type_traits/is_stateless.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 1 3 4
># 21 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 22 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
>
>template <typename T>
>struct has_trivial_copy_impl
>{
>
> static const bool value = ((__has_trivial_copy(T) ) && !is_reference<T>::value && ! ::boost::is_volatile<T>::value);
>
>
>
>
>
>
>
>};
>
>}
>
>template< typename T > struct has_trivial_copy : public ::boost::integral_constant<bool,::boost::detail::has_trivial_copy_impl<T>::value> { public: };
>template< typename T > struct has_trivial_copy_constructor : public ::boost::integral_constant<bool,::boost::detail::has_trivial_copy_impl<T>::value> { public: };
>
>template<> struct has_trivial_copy< void > : public ::boost::integral_constant<bool,false> { public: };
>
>template<> struct has_trivial_copy< void const > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_trivial_copy< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_trivial_copy< void volatile > : public ::boost::integral_constant<bool,false> { public: };
>
>
>template<> struct has_trivial_copy_constructor< void > : public ::boost::integral_constant<bool,false> { public: };
>
>template<> struct has_trivial_copy_constructor< void const > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_trivial_copy_constructor< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_trivial_copy_constructor< void volatile > : public ::boost::integral_constant<bool,false> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 63 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 2 3 4
># 14 "/usr/include/boost/type_traits/is_stateless.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 1 3 4
># 18 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 19 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
>
>template <typename T>
>struct has_trivial_dtor_impl
>{
>
> static const bool value = (__has_trivial_destructor(T) );
>
>
>
>};
>
>}
>
>template< typename T > struct has_trivial_destructor : public ::boost::integral_constant<bool,::boost::detail::has_trivial_dtor_impl<T>::value> { public: };
>
>template<> struct has_trivial_destructor< void > : public ::boost::integral_constant<bool,false> { public: };
>
>template<> struct has_trivial_destructor< void const > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_trivial_destructor< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_trivial_destructor< void volatile > : public ::boost::integral_constant<bool,false> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 48 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 2 3 4
># 15 "/usr/include/boost/type_traits/is_stateless.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/is_empty.hpp" 1 3 4
># 32 "/usr/include/boost/type_traits/is_empty.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 33 "/usr/include/boost/type_traits/is_empty.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost {
>
>namespace detail {
># 51 "/usr/include/boost/type_traits/is_empty.hpp" 3 4
>template <typename T>
>struct empty_helper_t1 : public T
>{
> empty_helper_t1();
> int i[256];
>private:
>
> empty_helper_t1(const empty_helper_t1&);
> empty_helper_t1& operator=(const empty_helper_t1&);
>};
>
>
>
>
>
>struct empty_helper_t2 { int i[256]; };
>
>
>
>template <typename T, bool is_a_class = false>
>struct empty_helper
>{
> static const bool value = false;
>};
>
>template <typename T>
>struct empty_helper<T, true>
>{
> static const bool value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2))
>
> ;
>};
>
>template <typename T>
>struct is_empty_impl
>{
> typedef typename remove_cv<T>::type cvt;
> static const bool value = ( ::boost::type_traits::ice_or< ::boost::detail::empty_helper<cvt,::boost::is_class<T>::value>::value , false >::value )
>
>
>
>
>
> ;
>};
># 211 "/usr/include/boost/type_traits/is_empty.hpp" 3 4
>template<> struct is_empty_impl< void > { public: static const bool value = (false); };
>
>template<> struct is_empty_impl< void const > { public: static const bool value = (false); };
>template<> struct is_empty_impl< void volatile > { public: static const bool value = (false); };
>template<> struct is_empty_impl< void const volatile > { public: static const bool value = (false); };
>
>
>}
>
>template< typename T > struct is_empty : public ::boost::integral_constant<bool,::boost::detail::is_empty_impl<T>::value> { public: };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 225 "/usr/include/boost/type_traits/is_empty.hpp" 2 3 4
># 17 "/usr/include/boost/type_traits/is_stateless.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 22 "/usr/include/boost/type_traits/is_stateless.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
>
>template <typename T>
>struct is_stateless_impl
>{
> static const bool value = (::boost::type_traits::ice_and< ::boost::has_trivial_constructor<T>::value, ::boost::has_trivial_copy<T>::value, ::boost::has_trivial_destructor<T>::value, ::boost::is_class<T>::value, ::boost::is_empty<T>::value >::value)
>
>
>
>
>
>
> ;
>};
>
>}
>
>template< typename T > struct is_stateless : public ::boost::integral_constant<bool,::boost::detail::is_stateless_impl<T>::value> { public: };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 47 "/usr/include/boost/type_traits/is_stateless.hpp" 2 3 4
># 22 "/usr/include/boost/circular_buffer/base.hpp" 2 3 4
>
>
># 1 "/usr/include/c++/4.8.2/algorithm" 1 3 4
># 58 "/usr/include/c++/4.8.2/algorithm" 3 4
> 
># 59 "/usr/include/c++/4.8.2/algorithm" 3
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/stl_algo.h" 1 3
># 59 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
># 1 "/usr/include/c++/4.8.2/cstdlib" 1 3
># 39 "/usr/include/c++/4.8.2/cstdlib" 3
> 
># 40 "/usr/include/c++/4.8.2/cstdlib" 3
># 60 "/usr/include/c++/4.8.2/bits/stl_algo.h" 2 3
># 1 "/usr/include/c++/4.8.2/bits/algorithmfwd.h" 1 3
># 33 "/usr/include/c++/4.8.2/bits/algorithmfwd.h" 3
> 
># 34 "/usr/include/c++/4.8.2/bits/algorithmfwd.h" 3
># 42 "/usr/include/c++/4.8.2/bits/algorithmfwd.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 194 "/usr/include/c++/4.8.2/bits/algorithmfwd.h" 3
> template<typename _IIter, typename _Predicate>
> bool
> all_of(_IIter, _IIter, _Predicate);
>
> template<typename _IIter, typename _Predicate>
> bool
> any_of(_IIter, _IIter, _Predicate);
>
>
> template<typename _FIter, typename _Tp>
> bool
> binary_search(_FIter, _FIter, const _Tp&);
>
> template<typename _FIter, typename _Tp, typename _Compare>
> bool
> binary_search(_FIter, _FIter, const _Tp&, _Compare);
>
> template<typename _IIter, typename _OIter>
> _OIter
> copy(_IIter, _IIter, _OIter);
>
> template<typename _BIter1, typename _BIter2>
> _BIter2
> copy_backward(_BIter1, _BIter1, _BIter2);
>
>
> template<typename _IIter, typename _OIter, typename _Predicate>
> _OIter
> copy_if(_IIter, _IIter, _OIter, _Predicate);
>
> template<typename _IIter, typename _Size, typename _OIter>
> _OIter
> copy_n(_IIter, _Size, _OIter);
>
>
>
>
>
> template<typename _FIter, typename _Tp>
> pair<_FIter, _FIter>
> equal_range(_FIter, _FIter, const _Tp&);
>
> template<typename _FIter, typename _Tp, typename _Compare>
> pair<_FIter, _FIter>
> equal_range(_FIter, _FIter, const _Tp&, _Compare);
>
> template<typename _FIter, typename _Tp>
> void
> fill(_FIter, _FIter, const _Tp&);
>
> template<typename _OIter, typename _Size, typename _Tp>
> _OIter
> fill_n(_OIter, _Size, const _Tp&);
>
>
>
> template<typename _FIter1, typename _FIter2>
> _FIter1
> find_end(_FIter1, _FIter1, _FIter2, _FIter2);
>
> template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
> _FIter1
> find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
>
>
>
>
>
> template<typename _IIter, typename _Predicate>
> _IIter
> find_if_not(_IIter, _IIter, _Predicate);
>
>
>
>
>
>
> template<typename _IIter1, typename _IIter2>
> bool
> includes(_IIter1, _IIter1, _IIter2, _IIter2);
>
> template<typename _IIter1, typename _IIter2, typename _Compare>
> bool
> includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
>
> template<typename _BIter>
> void
> inplace_merge(_BIter, _BIter, _BIter);
>
> template<typename _BIter, typename _Compare>
> void
> inplace_merge(_BIter, _BIter, _BIter, _Compare);
>
>
> template<typename _RAIter>
> bool
> is_heap(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> bool
> is_heap(_RAIter, _RAIter, _Compare);
>
> template<typename _RAIter>
> _RAIter
> is_heap_until(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> _RAIter
> is_heap_until(_RAIter, _RAIter, _Compare);
>
> template<typename _IIter, typename _Predicate>
> bool
> is_partitioned(_IIter, _IIter, _Predicate);
>
> template<typename _FIter1, typename _FIter2>
> bool
> is_permutation(_FIter1, _FIter1, _FIter2);
>
> template<typename _FIter1, typename _FIter2,
> typename _BinaryPredicate>
> bool
> is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
>
> template<typename _FIter>
> bool
> is_sorted(_FIter, _FIter);
>
> template<typename _FIter, typename _Compare>
> bool
> is_sorted(_FIter, _FIter, _Compare);
>
> template<typename _FIter>
> _FIter
> is_sorted_until(_FIter, _FIter);
>
> template<typename _FIter, typename _Compare>
> _FIter
> is_sorted_until(_FIter, _FIter, _Compare);
>
>
> template<typename _FIter1, typename _FIter2>
> void
> iter_swap(_FIter1, _FIter2);
>
> template<typename _FIter, typename _Tp>
> _FIter
> lower_bound(_FIter, _FIter, const _Tp&);
>
> template<typename _FIter, typename _Tp, typename _Compare>
> _FIter
> lower_bound(_FIter, _FIter, const _Tp&, _Compare);
>
> template<typename _RAIter>
> void
> make_heap(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> make_heap(_RAIter, _RAIter, _Compare);
>
> template<typename _Tp>
> const _Tp&
> max(const _Tp&, const _Tp&);
>
> template<typename _Tp, typename _Compare>
> const _Tp&
> max(const _Tp&, const _Tp&, _Compare);
>
>
>
>
> template<typename _Tp>
> const _Tp&
> min(const _Tp&, const _Tp&);
>
> template<typename _Tp, typename _Compare>
> const _Tp&
> min(const _Tp&, const _Tp&, _Compare);
>
>
>
>
> template<typename _Tp>
> pair<const _Tp&, const _Tp&>
> minmax(const _Tp&, const _Tp&);
>
> template<typename _Tp, typename _Compare>
> pair<const _Tp&, const _Tp&>
> minmax(const _Tp&, const _Tp&, _Compare);
>
> template<typename _FIter>
> pair<_FIter, _FIter>
> minmax_element(_FIter, _FIter);
>
> template<typename _FIter, typename _Compare>
> pair<_FIter, _FIter>
> minmax_element(_FIter, _FIter, _Compare);
>
> template<typename _Tp>
> _Tp
> min(initializer_list<_Tp>);
>
> template<typename _Tp, typename _Compare>
> _Tp
> min(initializer_list<_Tp>, _Compare);
>
> template<typename _Tp>
> _Tp
> max(initializer_list<_Tp>);
>
> template<typename _Tp, typename _Compare>
> _Tp
> max(initializer_list<_Tp>, _Compare);
>
> template<typename _Tp>
> pair<_Tp, _Tp>
> minmax(initializer_list<_Tp>);
>
> template<typename _Tp, typename _Compare>
> pair<_Tp, _Tp>
> minmax(initializer_list<_Tp>, _Compare);
>
>
>
>
> template<typename _BIter>
> bool
> next_permutation(_BIter, _BIter);
>
> template<typename _BIter, typename _Compare>
> bool
> next_permutation(_BIter, _BIter, _Compare);
>
>
> template<typename _IIter, typename _Predicate>
> bool
> none_of(_IIter, _IIter, _Predicate);
>
>
>
>
>
> template<typename _IIter, typename _RAIter>
> _RAIter
> partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
>
> template<typename _IIter, typename _RAIter, typename _Compare>
> _RAIter
> partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
>
>
>
>
> template<typename _IIter, typename _OIter1,
> typename _OIter2, typename _Predicate>
> pair<_OIter1, _OIter2>
> partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
>
> template<typename _FIter, typename _Predicate>
> _FIter
> partition_point(_FIter, _FIter, _Predicate);
>
>
> template<typename _RAIter>
> void
> pop_heap(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> pop_heap(_RAIter, _RAIter, _Compare);
>
> template<typename _BIter>
> bool
> prev_permutation(_BIter, _BIter);
>
> template<typename _BIter, typename _Compare>
> bool
> prev_permutation(_BIter, _BIter, _Compare);
>
> template<typename _RAIter>
> void
> push_heap(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> push_heap(_RAIter, _RAIter, _Compare);
>
>
>
> template<typename _FIter, typename _Tp>
> _FIter
> remove(_FIter, _FIter, const _Tp&);
>
> template<typename _FIter, typename _Predicate>
> _FIter
> remove_if(_FIter, _FIter, _Predicate);
>
> template<typename _IIter, typename _OIter, typename _Tp>
> _OIter
> remove_copy(_IIter, _IIter, _OIter, const _Tp&);
>
> template<typename _IIter, typename _OIter, typename _Predicate>
> _OIter
> remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
>
>
>
> template<typename _IIter, typename _OIter, typename _Tp>
> _OIter
> replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
>
> template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
> _OIter
> replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
>
>
>
> template<typename _BIter>
> void
> reverse(_BIter, _BIter);
>
> template<typename _BIter, typename _OIter>
> _OIter
> reverse_copy(_BIter, _BIter, _OIter);
>
> template<typename _FIter>
> void
> rotate(_FIter, _FIter, _FIter);
>
> template<typename _FIter, typename _OIter>
> _OIter
> rotate_copy(_FIter, _FIter, _FIter, _OIter);
># 535 "/usr/include/c++/4.8.2/bits/algorithmfwd.h" 3
> template<typename _RAIter, typename _UGenerator>
> void
> shuffle(_RAIter, _RAIter, _UGenerator&&);
>
>
> template<typename _RAIter>
> void
> sort_heap(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> sort_heap(_RAIter, _RAIter, _Compare);
>
> template<typename _BIter, typename _Predicate>
> _BIter
> stable_partition(_BIter, _BIter, _Predicate);
>
> template<typename _Tp>
> void
> swap(_Tp&, _Tp&)
>
> noexcept(__and_<is_nothrow_move_constructible<_Tp>,
> is_nothrow_move_assignable<_Tp>>::value)
>
> ;
>
> template<typename _Tp, size_t _Nm>
> void
> swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
>
> noexcept(noexcept(swap(*__a, *__b)))
>
> ;
>
> template<typename _FIter1, typename _FIter2>
> _FIter2
> swap_ranges(_FIter1, _FIter1, _FIter2);
>
>
>
> template<typename _FIter>
> _FIter
> unique(_FIter, _FIter);
>
> template<typename _FIter, typename _BinaryPredicate>
> _FIter
> unique(_FIter, _FIter, _BinaryPredicate);
>
>
>
> template<typename _FIter, typename _Tp>
> _FIter
> upper_bound(_FIter, _FIter, const _Tp&);
>
> template<typename _FIter, typename _Tp, typename _Compare>
> _FIter
> upper_bound(_FIter, _FIter, const _Tp&, _Compare);
>
>
>
>
>
> template<typename _FIter>
> _FIter
> adjacent_find(_FIter, _FIter);
>
> template<typename _FIter, typename _BinaryPredicate>
> _FIter
> adjacent_find(_FIter, _FIter, _BinaryPredicate);
>
> template<typename _IIter, typename _Tp>
> typename iterator_traits<_IIter>::difference_type
> count(_IIter, _IIter, const _Tp&);
>
> template<typename _IIter, typename _Predicate>
> typename iterator_traits<_IIter>::difference_type
> count_if(_IIter, _IIter, _Predicate);
>
> template<typename _IIter1, typename _IIter2>
> bool
> equal(_IIter1, _IIter1, _IIter2);
>
> template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
> bool
> equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
>
> template<typename _IIter, typename _Tp>
> _IIter
> find(_IIter, _IIter, const _Tp&);
>
> template<typename _FIter1, typename _FIter2>
> _FIter1
> find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
>
> template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
> _FIter1
> find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
>
> template<typename _IIter, typename _Predicate>
> _IIter
> find_if(_IIter, _IIter, _Predicate);
>
> template<typename _IIter, typename _Funct>
> _Funct
> for_each(_IIter, _IIter, _Funct);
>
> template<typename _FIter, typename _Generator>
> void
> generate(_FIter, _FIter, _Generator);
>
> template<typename _OIter, typename _Size, typename _Generator>
> _OIter
> generate_n(_OIter, _Size, _Generator);
>
> template<typename _IIter1, typename _IIter2>
> bool
> lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
>
> template<typename _IIter1, typename _IIter2, typename _Compare>
> bool
> lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
>
> template<typename _FIter>
> _FIter
> max_element(_FIter, _FIter);
>
> template<typename _FIter, typename _Compare>
> _FIter
> max_element(_FIter, _FIter, _Compare);
>
> template<typename _IIter1, typename _IIter2, typename _OIter>
> _OIter
> merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _Compare>
> _OIter
> merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
> template<typename _FIter>
> _FIter
> min_element(_FIter, _FIter);
>
> template<typename _FIter, typename _Compare>
> _FIter
> min_element(_FIter, _FIter, _Compare);
>
> template<typename _IIter1, typename _IIter2>
> pair<_IIter1, _IIter2>
> mismatch(_IIter1, _IIter1, _IIter2);
>
> template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
> pair<_IIter1, _IIter2>
> mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
>
> template<typename _RAIter>
> void
> nth_element(_RAIter, _RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> nth_element(_RAIter, _RAIter, _RAIter, _Compare);
>
> template<typename _RAIter>
> void
> partial_sort(_RAIter, _RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
>
> template<typename _BIter, typename _Predicate>
> _BIter
> partition(_BIter, _BIter, _Predicate);
>
> template<typename _RAIter>
> void
> random_shuffle(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Generator>
> void
> random_shuffle(_RAIter, _RAIter,
>
> _Generator&&);
>
>
>
>
> template<typename _FIter, typename _Tp>
> void
> replace(_FIter, _FIter, const _Tp&, const _Tp&);
>
> template<typename _FIter, typename _Predicate, typename _Tp>
> void
> replace_if(_FIter, _FIter, _Predicate, const _Tp&);
>
> template<typename _FIter1, typename _FIter2>
> _FIter1
> search(_FIter1, _FIter1, _FIter2, _FIter2);
>
> template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
> _FIter1
> search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
>
> template<typename _FIter, typename _Size, typename _Tp>
> _FIter
> search_n(_FIter, _FIter, _Size, const _Tp&);
>
> template<typename _FIter, typename _Size, typename _Tp,
> typename _BinaryPredicate>
> _FIter
> search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
>
> template<typename _IIter1, typename _IIter2, typename _OIter>
> _OIter
> set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _Compare>
> _OIter
> set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
> template<typename _IIter1, typename _IIter2, typename _OIter>
> _OIter
> set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _Compare>
> _OIter
> set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
> template<typename _IIter1, typename _IIter2, typename _OIter>
> _OIter
> set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _Compare>
> _OIter
> set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
> _OIter, _Compare);
>
> template<typename _IIter1, typename _IIter2, typename _OIter>
> _OIter
> set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _Compare>
> _OIter
> set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
> template<typename _RAIter>
> void
> sort(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> sort(_RAIter, _RAIter, _Compare);
>
> template<typename _RAIter>
> void
> stable_sort(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> stable_sort(_RAIter, _RAIter, _Compare);
>
> template<typename _IIter, typename _OIter, typename _UnaryOperation>
> _OIter
> transform(_IIter, _IIter, _OIter, _UnaryOperation);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _BinaryOperation>
> _OIter
> transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
>
> template<typename _IIter, typename _OIter>
> _OIter
> unique_copy(_IIter, _IIter, _OIter);
>
> template<typename _IIter, typename _OIter, typename _BinaryPredicate>
> _OIter
> unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
>
>
>}
># 61 "/usr/include/c++/4.8.2/bits/stl_algo.h" 2 3
># 1 "/usr/include/c++/4.8.2/bits/stl_heap.h" 1 3
># 61 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Distance>
> _Distance
> __is_heap_until(_RandomAccessIterator __first, _Distance __n)
> {
> _Distance __parent = 0;
> for (_Distance __child = 1; __child < __n; ++__child)
> {
> if (__first[__parent] < __first[__child])
> return __child;
> if ((__child & 1) == 0)
> ++__parent;
> }
> return __n;
> }
>
> template<typename _RandomAccessIterator, typename _Distance,
> typename _Compare>
> _Distance
> __is_heap_until(_RandomAccessIterator __first, _Distance __n,
> _Compare __comp)
> {
> _Distance __parent = 0;
> for (_Distance __child = 1; __child < __n; ++__child)
> {
> if (__comp(__first[__parent], __first[__child]))
> return __child;
> if ((__child & 1) == 0)
> ++__parent;
> }
> return __n;
> }
>
>
>
> template<typename _RandomAccessIterator, typename _Distance>
> inline bool
> __is_heap(_RandomAccessIterator __first, _Distance __n)
> { return std::__is_heap_until(__first, __n) == __n; }
>
> template<typename _RandomAccessIterator, typename _Compare,
> typename _Distance>
> inline bool
> __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
> { return std::__is_heap_until(__first, __n, __comp) == __n; }
>
> template<typename _RandomAccessIterator>
> inline bool
> __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> { return std::__is_heap(__first, std::distance(__first, __last)); }
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline bool
> __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> { return std::__is_heap(__first, __comp, std::distance(__first, __last)); }
>
>
>
>
> template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
> void
> __push_heap(_RandomAccessIterator __first,
> _Distance __holeIndex, _Distance __topIndex, _Tp __value)
> {
> _Distance __parent = (__holeIndex - 1) / 2;
> while (__holeIndex > __topIndex && *(__first + __parent) < __value)
> {
> *(__first + __holeIndex) = std::move(*(__first + __parent));
> __holeIndex = __parent;
> __parent = (__holeIndex - 1) / 2;
> }
> *(__first + __holeIndex) = std::move(__value);
> }
># 154 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline void
> push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
> ;
> ;
>
> _ValueType __value = std::move(*(__last - 1));
> std::__push_heap(__first, _DistanceType((__last - __first) - 1),
> _DistanceType(0), std::move(__value));
> }
>
> template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
> typename _Compare>
> void
> __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
> _Distance __topIndex, _Tp __value, _Compare __comp)
> {
> _Distance __parent = (__holeIndex - 1) / 2;
> while (__holeIndex > __topIndex
> && __comp(*(__first + __parent), __value))
> {
> *(__first + __holeIndex) = std::move(*(__first + __parent));
> __holeIndex = __parent;
> __parent = (__holeIndex - 1) / 2;
> }
> *(__first + __holeIndex) = std::move(__value);
> }
># 204 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> ;
> ;
>
> _ValueType __value = std::move(*(__last - 1));
> std::__push_heap(__first, _DistanceType((__last - __first) - 1),
> _DistanceType(0), std::move(__value), __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
> void
> __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
> _Distance __len, _Tp __value)
> {
> const _Distance __topIndex = __holeIndex;
> _Distance __secondChild = __holeIndex;
> while (__secondChild < (__len - 1) / 2)
> {
> __secondChild = 2 * (__secondChild + 1);
> if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
> __secondChild--;
> *(__first + __holeIndex) = std::move(*(__first + __secondChild));
> __holeIndex = __secondChild;
> }
> if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
> {
> __secondChild = 2 * (__secondChild + 1);
> *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1)))
> ;
> __holeIndex = __secondChild - 1;
> }
> std::__push_heap(__first, __holeIndex, __topIndex,
> std::move(__value));
> }
>
> template<typename _RandomAccessIterator>
> inline void
> __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _RandomAccessIterator __result)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
> _ValueType __value = std::move(*__result);
> *__result = std::move(*__first);
> std::__adjust_heap(__first, _DistanceType(0),
> _DistanceType(__last - __first),
> std::move(__value));
> }
># 279 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline void
> pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
> ;
> ;
>
> if (__last - __first > 1)
> {
> --__last;
> std::__pop_heap(__first, __last, __last);
> }
> }
>
> template<typename _RandomAccessIterator, typename _Distance,
> typename _Tp, typename _Compare>
> void
> __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
> _Distance __len, _Tp __value, _Compare __comp)
> {
> const _Distance __topIndex = __holeIndex;
> _Distance __secondChild = __holeIndex;
> while (__secondChild < (__len - 1) / 2)
> {
> __secondChild = 2 * (__secondChild + 1);
> if (__comp(*(__first + __secondChild),
> *(__first + (__secondChild - 1))))
> __secondChild--;
> *(__first + __holeIndex) = std::move(*(__first + __secondChild));
> __holeIndex = __secondChild;
> }
> if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
> {
> __secondChild = 2 * (__secondChild + 1);
> *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1)))
> ;
> __holeIndex = __secondChild - 1;
> }
> std::__push_heap(__first, __holeIndex, __topIndex,
> std::move(__value), __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _RandomAccessIterator __result, _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
> _ValueType __value = std::move(*__result);
> *__result = std::move(*__first);
> std::__adjust_heap(__first, _DistanceType(0),
> _DistanceType(__last - __first),
> std::move(__value), __comp);
> }
># 357 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> pop_heap(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
>
> 
>
> ;
> ;
> ;
>
> if (__last - __first > 1)
> {
> --__last;
> std::__pop_heap(__first, __last, __last, __comp);
> }
> }
># 384 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> void
> make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
> ;
>
> if (__last - __first < 2)
> return;
>
> const _DistanceType __len = __last - __first;
> _DistanceType __parent = (__len - 2) / 2;
> while (true)
> {
> _ValueType __value = std::move(*(__first + __parent));
> std::__adjust_heap(__first, __parent, __len, std::move(__value));
> if (__parent == 0)
> return;
> __parent--;
> }
> }
># 424 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> void
> make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> ;
>
> if (__last - __first < 2)
> return;
>
> const _DistanceType __len = __last - __first;
> _DistanceType __parent = (__len - 2) / 2;
> while (true)
> {
> _ValueType __value = std::move(*(__first + __parent));
> std::__adjust_heap(__first, __parent, __len, std::move(__value),
> __comp);
> if (__parent == 0)
> return;
> __parent--;
> }
> }
># 463 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> void
> sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> 
>
> ;
> ;
>
> while (__last - __first > 1)
> {
> --__last;
> std::__pop_heap(__first, __last, __last);
> }
> }
># 492 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> void
> sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
>
> 
>
> ;
> ;
>
> while (__last - __first > 1)
> {
> --__last;
> std::__pop_heap(__first, __last, __last, __comp);
> }
> }
># 521 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline _RandomAccessIterator
> is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> 
>
> ;
>
> return __first + std::__is_heap_until(__first, std::distance(__first,
> __last));
> }
># 547 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline _RandomAccessIterator
> is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
>
> 
>
> ;
>
> return __first + std::__is_heap_until(__first, std::distance(__first,
> __last),
> __comp);
> }
># 569 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline bool
> is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> { return std::is_heap_until(__first, __last) == __last; }
># 582 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline bool
> is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> { return std::is_heap_until(__first, __last, __comp) == __last; }
>
>
>
>}
># 62 "/usr/include/c++/4.8.2/bits/stl_algo.h" 2 3
>
>
>
># 1 "/usr/include/c++/4.8.2/random" 1 3
># 32 "/usr/include/c++/4.8.2/random" 3
> 
># 33 "/usr/include/c++/4.8.2/random" 3
>
>
>
>
>
># 1 "/usr/include/c++/4.8.2/cmath" 1 3
># 39 "/usr/include/c++/4.8.2/cmath" 3
> 
># 40 "/usr/include/c++/4.8.2/cmath" 3
># 39 "/usr/include/c++/4.8.2/random" 2 3
># 1 "/usr/include/c++/4.8.2/cstdio" 1 3
># 39 "/usr/include/c++/4.8.2/cstdio" 3
> 
># 40 "/usr/include/c++/4.8.2/cstdio" 3
># 40 "/usr/include/c++/4.8.2/random" 2 3
># 1 "/usr/include/c++/4.8.2/cstdlib" 1 3
># 39 "/usr/include/c++/4.8.2/cstdlib" 3
> 
># 40 "/usr/include/c++/4.8.2/cstdlib" 3
># 41 "/usr/include/c++/4.8.2/random" 2 3
># 50 "/usr/include/c++/4.8.2/random" 3
># 1 "/usr/include/c++/4.8.2/bits/random.h" 1 3
># 36 "/usr/include/c++/4.8.2/bits/random.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 55 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType, size_t __bits,
> typename _UniformRandomNumberGenerator>
> _RealType
> generate_canonical(_UniformRandomNumberGenerator& __g);
>
>
>
>
>
>
> namespace __detail
> {
> 
>
> template<typename _UIntType, size_t __w,
> bool = __w < static_cast<size_t>
> (std::numeric_limits<_UIntType>::digits)>
> struct _Shift
> { static const _UIntType __value = 0; };
>
> template<typename _UIntType, size_t __w>
> struct _Shift<_UIntType, __w, true>
> { static const _UIntType __value = _UIntType(1) << __w; };
>
> template<int __s,
> int __which = ((__s <= 8 * sizeof (int))
> + (__s <= 8 * sizeof (long))
> + (__s <= 8 * sizeof (long long))
>
> + (__s <= 128))>
> struct _Select_uint_least_t
> {
> static_assert(__which < 0,
> "sorry, would be too much trouble for a slow result");
> };
>
> template<int __s>
> struct _Select_uint_least_t<__s, 4>
> { typedef unsigned int type; };
>
> template<int __s>
> struct _Select_uint_least_t<__s, 3>
> { typedef unsigned long type; };
>
> template<int __s>
> struct _Select_uint_least_t<__s, 2>
> { typedef unsigned long long type; };
>
>
> template<int __s>
> struct _Select_uint_least_t<__s, 1>
> { typedef unsigned __int128 type; };
>
>
>
> template<typename _Tp, _Tp __m, _Tp __a, _Tp __c,
> bool __big_enough = (!(__m & (__m - 1))
> || (_Tp(-1) - __c) / __a >= __m - 1),
> bool __schrage_ok = __m % __a < __m / __a>
> struct _Mod
> {
> typedef typename _Select_uint_least_t<std::__lg(__a)
> + std::__lg(__m) + 2>::type _Tp2;
> static _Tp
> __calc(_Tp __x)
> { return static_cast<_Tp>((_Tp2(__a) * __x + __c) % __m); }
> };
>
>
> template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
> struct _Mod<_Tp, __m, __a, __c, false, true>
> {
> static _Tp
> __calc(_Tp __x);
> };
>
>
>
>
> template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool __s>
> struct _Mod<_Tp, __m, __a, __c, true, __s>
> {
> static _Tp
> __calc(_Tp __x)
> {
> _Tp __res = __a * __x + __c;
> if (__m)
> __res %= __m;
> return __res;
> }
> };
>
> template<typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
> inline _Tp
> __mod(_Tp __x)
> { return _Mod<_Tp, __m, __a, __c>::__calc(__x); }
>
>
> template<typename _Tp>
> inline bool
> _Power_of_2(_Tp __x)
> {
> return ((__x - 1) & __x) == 0;
> };
>
>
>
>
>
> template<typename _Engine, typename _DInputType>
> struct _Adaptor
> {
>
> public:
> _Adaptor(_Engine& __g)
> : _M_g(__g) { }
>
> _DInputType
> min() const
> { return _DInputType(0); }
>
> _DInputType
> max() const
> { return _DInputType(1); }
>
>
>
>
>
>
> _DInputType
> operator()()
> {
> return std::generate_canonical<_DInputType,
> std::numeric_limits<_DInputType>::digits,
> _Engine>(_M_g);
> }
>
> private:
> _Engine& _M_g;
> };
>
> 
> }
>
>
># 240 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> class linear_congruential_engine
> {
> static_assert(std::is_unsigned<_UIntType>::value, "template argument "
> "substituting _UIntType not an unsigned integral type");
> static_assert(__m == 0u || (__a < __m && __c < __m),
> "template argument substituting __m out of bounds");
>
> public:
>
> typedef _UIntType result_type;
>
>
> static constexpr result_type multiplier = __a;
>
> static constexpr result_type increment = __c;
>
> static constexpr result_type modulus = __m;
> static constexpr result_type default_seed = 1u;
># 267 "/usr/include/c++/4.8.2/bits/random.h" 3
> explicit
> linear_congruential_engine(result_type __s = default_seed)
> { seed(__s); }
>
>
>
>
>
>
>
> template<typename _Sseq, typename = typename
> std::enable_if<!std::is_same<_Sseq, linear_congruential_engine>::value>
> ::type>
> explicit
> linear_congruential_engine(_Sseq& __q)
> { seed(__q); }
>
>
>
>
>
>
>
> void
> seed(result_type __s = default_seed);
># 300 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _Sseq>
> typename std::enable_if<std::is_class<_Sseq>::value>::type
> seed(_Sseq& __q);
>
>
>
>
>
>
>
> static constexpr result_type
> min()
> { return __c == 0u ? 1u : 0u; }
>
>
>
>
> static constexpr result_type
> max()
> { return __m - 1u; }
>
>
>
>
> void
> discard(unsigned long long __z)
> {
> for (; __z != 0ULL; --__z)
> (*this)();
> }
>
>
>
>
> result_type
> operator()()
> {
> _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
> return _M_x;
> }
># 352 "/usr/include/c++/4.8.2/bits/random.h" 3
> friend bool
> operator==(const linear_congruential_engine& __lhs,
> const linear_congruential_engine& __rhs)
> { return __lhs._M_x == __rhs._M_x; }
># 365 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _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 std::linear_congruential_engine<_UIntType1,
> __a1, __c1, __m1>& __lcr);
># 385 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
> _UIntType1 __m1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::linear_congruential_engine<_UIntType1, __a1,
> __c1, __m1>& __lcr);
>
> private:
> _UIntType _M_x;
> };
># 407 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> inline bool
> operator!=(const std::linear_congruential_engine<_UIntType, __a,
> __c, __m>& __lhs,
> const std::linear_congruential_engine<_UIntType, __a,
> __c, __m>& __rhs)
> { return !(__lhs == __rhs); }
># 444 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _UIntType, size_t __w,
> size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t,
> _UIntType __c, size_t __l, _UIntType __f>
> class mersenne_twister_engine
> {
> static_assert(std::is_unsigned<_UIntType>::value, "template argument "
> "substituting _UIntType not an unsigned integral type");
> static_assert(1u <= __m && __m <= __n,
> "template argument substituting __m out of bounds");
> static_assert(__r <= __w, "template argument substituting "
> "__r out of bound");
> static_assert(__u <= __w, "template argument substituting "
> "__u out of bound");
> static_assert(__s <= __w, "template argument substituting "
> "__s out of bound");
> static_assert(__t <= __w, "template argument substituting "
> "__t out of bound");
> static_assert(__l <= __w, "template argument substituting "
> "__l out of bound");
> static_assert(__w <= std::numeric_limits<_UIntType>::digits,
> "template argument substituting __w out of bound");
> static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
> "template argument substituting __a out of bound");
> static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
> "template argument substituting __b out of bound");
> static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
> "template argument substituting __c out of bound");
> static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
> "template argument substituting __d out of bound");
> static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
> "template argument substituting __f out of bound");
>
> public:
>
> typedef _UIntType result_type;
>
>
> static constexpr size_t word_size = __w;
> static constexpr size_t state_size = __n;
> static constexpr size_t shift_size = __m;
> static constexpr size_t mask_bits = __r;
> static constexpr result_type xor_mask = __a;
> static constexpr size_t tempering_u = __u;
> static constexpr result_type tempering_d = __d;
> static constexpr size_t tempering_s = __s;
> static constexpr result_type tempering_b = __b;
> static constexpr size_t tempering_t = __t;
> static constexpr result_type tempering_c = __c;
> static constexpr size_t tempering_l = __l;
> static constexpr result_type initialization_multiplier = __f;
> static constexpr result_type default_seed = 5489u;
>
>
> explicit
> mersenne_twister_engine(result_type __sd = default_seed)
> { seed(__sd); }
>
>
>
>
>
>
>
> template<typename _Sseq, typename = typename
> std::enable_if<!std::is_same<_Sseq, mersenne_twister_engine>::value>
> ::type>
> explicit
> mersenne_twister_engine(_Sseq& __q)
> { seed(__q); }
>
> void
> seed(result_type __sd = default_seed);
>
> template<typename _Sseq>
> typename std::enable_if<std::is_class<_Sseq>::value>::type
> seed(_Sseq& __q);
>
>
>
>
> static constexpr result_type
> min()
> { return 0; };
>
>
>
>
> static constexpr result_type
> max()
> { return __detail::_Shift<_UIntType, __w>::__value - 1; }
>
>
>
>
> void
> discard(unsigned long long __z);
>
> result_type
> operator()();
># 558 "/usr/include/c++/4.8.2/bits/random.h" 3
> friend bool
> operator==(const mersenne_twister_engine& __lhs,
> const mersenne_twister_engine& __rhs)
> { return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
> && __lhs._M_p == __rhs._M_p); }
># 576 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _UIntType1,
> size_t __w1, size_t __n1,
> size_t __m1, size_t __r1,
> _UIntType1 __a1, size_t __u1,
> _UIntType1 __d1, size_t __s1,
> _UIntType1 __b1, size_t __t1,
> _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
> typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::mersenne_twister_engine<_UIntType1, __w1, __n1,
> __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
> __l1, __f1>& __x);
># 602 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _UIntType1,
> size_t __w1, size_t __n1,
> size_t __m1, size_t __r1,
> _UIntType1 __a1, size_t __u1,
> _UIntType1 __d1, size_t __s1,
> _UIntType1 __b1, size_t __t1,
> _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
> typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1,
> __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
> __l1, __f1>& __x);
>
> private:
> void _M_gen_rand();
>
> _UIntType _M_x[state_size];
> size_t _M_p;
> };
># 635 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _UIntType, size_t __w,
> size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t,
> _UIntType __c, size_t __l, _UIntType __f>
> inline bool
> operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
> __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
> const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
> __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
> { return !(__lhs == __rhs); }
># 667 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> class subtract_with_carry_engine
> {
> static_assert(std::is_unsigned<_UIntType>::value, "template argument "
> "substituting _UIntType not an unsigned integral type");
> static_assert(0u < __s && __s < __r,
> "template argument substituting __s out of bounds");
> static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
> "template argument substituting __w out of bounds");
>
> public:
>
> typedef _UIntType result_type;
>
>
> static constexpr size_t word_size = __w;
> static constexpr size_t short_lag = __s;
> static constexpr size_t long_lag = __r;
> static constexpr result_type default_seed = 19780503u;
>
>
>
>
>
> explicit
> subtract_with_carry_engine(result_type __sd = default_seed)
> { seed(__sd); }
>
>
>
>
>
>
>
> template<typename _Sseq, typename = typename
> std::enable_if<!std::is_same<_Sseq, subtract_with_carry_engine>::value>
> ::type>
> explicit
> subtract_with_carry_engine(_Sseq& __q)
> { seed(__q); }
># 720 "/usr/include/c++/4.8.2/bits/random.h" 3
> void
> seed(result_type __sd = default_seed);
>
>
>
>
>
> template<typename _Sseq>
> typename std::enable_if<std::is_class<_Sseq>::value>::type
> seed(_Sseq& __q);
>
>
>
>
>
> static constexpr result_type
> min()
> { return 0; }
>
>
>
>
>
> static constexpr result_type
> max()
> { return __detail::_Shift<_UIntType, __w>::__value - 1; }
>
>
>
>
> void
> discard(unsigned long long __z)
> {
> for (; __z != 0ULL; --__z)
> (*this)();
> }
>
>
>
>
> result_type
> operator()();
># 775 "/usr/include/c++/4.8.2/bits/random.h" 3
> friend bool
> operator==(const subtract_with_carry_engine& __lhs,
> const subtract_with_carry_engine& __rhs)
> { return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
> && __lhs._M_carry == __rhs._M_carry
> && __lhs._M_p == __rhs._M_p); }
># 794 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
> typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>&,
> const std::subtract_with_carry_engine<_UIntType1, __w1,
> __s1, __r1>&);
># 813 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
> typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>&,
> std::subtract_with_carry_engine<_UIntType1, __w1,
> __s1, __r1>&);
>
> private:
> _UIntType _M_x[long_lag];
> _UIntType _M_carry;
> size_t _M_p;
> };
># 838 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> inline bool
> operator!=(const std::subtract_with_carry_engine<_UIntType, __w,
> __s, __r>& __lhs,
> const std::subtract_with_carry_engine<_UIntType, __w,
> __s, __r>& __rhs)
> { return !(__lhs == __rhs); }
># 853 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RandomNumberEngine, size_t __p, size_t __r>
> class discard_block_engine
> {
> static_assert(1 <= __r && __r <= __p,
> "template argument substituting __r out of bounds");
>
> public:
>
> typedef typename _RandomNumberEngine::result_type result_type;
>
>
> static constexpr size_t block_size = __p;
> static constexpr size_t used_block = __r;
>
>
>
>
>
>
> discard_block_engine()
> : _M_b(), _M_n(0) { }
>
>
>
>
>
>
>
> explicit
> discard_block_engine(const _RandomNumberEngine& __rng)
> : _M_b(__rng), _M_n(0) { }
>
>
>
>
>
>
>
> explicit
> discard_block_engine(_RandomNumberEngine&& __rng)
> : _M_b(std::move(__rng)), _M_n(0) { }
>
>
>
>
>
>
>
> explicit
> discard_block_engine(result_type __s)
> : _M_b(__s), _M_n(0) { }
>
>
>
>
>
>
> template<typename _Sseq, typename = typename
> std::enable_if<!std::is_same<_Sseq, discard_block_engine>::value
> && !std::is_same<_Sseq, _RandomNumberEngine>::value>
> ::type>
> explicit
> discard_block_engine(_Sseq& __q)
> : _M_b(__q), _M_n(0)
> { }
>
>
>
>
>
> void
> seed()
> {
> _M_b.seed();
> _M_n = 0;
> }
>
>
>
>
>
> void
> seed(result_type __s)
> {
> _M_b.seed(__s);
> _M_n = 0;
> }
>
>
>
>
>
>
> template<typename _Sseq>
> void
> seed(_Sseq& __q)
> {
> _M_b.seed(__q);
> _M_n = 0;
> }
>
>
>
>
>
> const _RandomNumberEngine&
> base() const noexcept
> { return _M_b; }
>
>
>
>
> static constexpr result_type
> min()
> { return _RandomNumberEngine::min(); }
>
>
>
>
> static constexpr result_type
> max()
> { return _RandomNumberEngine::max(); }
>
>
>
>
> void
> discard(unsigned long long __z)
> {
> for (; __z != 0ULL; --__z)
> (*this)();
> }
>
>
>
>
> result_type
> operator()();
># 1003 "/usr/include/c++/4.8.2/bits/random.h" 3
> friend bool
> operator==(const discard_block_engine& __lhs,
> const discard_block_engine& __rhs)
> { return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
># 1019 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
> typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::discard_block_engine<_RandomNumberEngine1,
> __p1, __r1>& __x);
># 1037 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
> typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::discard_block_engine<_RandomNumberEngine1,
> __p1, __r1>& __x);
>
> private:
> _RandomNumberEngine _M_b;
> size_t _M_n;
> };
># 1060 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RandomNumberEngine, size_t __p, size_t __r>
> inline bool
> operator!=(const std::discard_block_engine<_RandomNumberEngine, __p,
> __r>& __lhs,
> const std::discard_block_engine<_RandomNumberEngine, __p,
> __r>& __rhs)
> { return !(__lhs == __rhs); }
>
>
>
>
>
>
> template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
> class independent_bits_engine
> {
> static_assert(std::is_unsigned<_UIntType>::value, "template argument "
> "substituting _UIntType not an unsigned integral type");
> static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
> "template argument substituting __w out of bounds");
>
> public:
>
> typedef _UIntType result_type;
>
>
>
>
>
>
> independent_bits_engine()
> : _M_b() { }
>
>
>
>
>
>
>
> explicit
> independent_bits_engine(const _RandomNumberEngine& __rng)
> : _M_b(__rng) { }
>
>
>
>
>
>
>
> explicit
> independent_bits_engine(_RandomNumberEngine&& __rng)
> : _M_b(std::move(__rng)) { }
>
>
>
>
>
>
>
> explicit
> independent_bits_engine(result_type __s)
> : _M_b(__s) { }
>
>
>
>
>
>
> template<typename _Sseq, typename = typename
> std::enable_if<!std::is_same<_Sseq, independent_bits_engine>::value
> && !std::is_same<_Sseq, _RandomNumberEngine>::value>
> ::type>
> explicit
> independent_bits_engine(_Sseq& __q)
> : _M_b(__q)
> { }
>
>
>
>
>
> void
> seed()
> { _M_b.seed(); }
>
>
>
>
>
> void
> seed(result_type __s)
> { _M_b.seed(__s); }
>
>
>
>
>
>
> template<typename _Sseq>
> void
> seed(_Sseq& __q)
> { _M_b.seed(__q); }
>
>
>
>
>
> const _RandomNumberEngine&
> base() const noexcept
> { return _M_b; }
>
>
>
>
> static constexpr result_type
> min()
> { return 0U; }
>
>
>
>
> static constexpr result_type
> max()
> { return __detail::_Shift<_UIntType, __w>::__value - 1; }
>
>
>
>
> void
> discard(unsigned long long __z)
> {
> for (; __z != 0ULL; --__z)
> (*this)();
> }
>
>
>
>
> result_type
> operator()();
># 1213 "/usr/include/c++/4.8.2/bits/random.h" 3
> friend bool
> operator==(const independent_bits_engine& __lhs,
> const independent_bits_engine& __rhs)
> { return __lhs._M_b == __rhs._M_b; }
># 1230 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::independent_bits_engine<_RandomNumberEngine,
> __w, _UIntType>& __x)
> {
> __is >> __x._M_b;
> return __is;
> }
>
> private:
> _RandomNumberEngine _M_b;
> };
># 1256 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
> inline bool
> operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w,
> _UIntType>& __lhs,
> const std::independent_bits_engine<_RandomNumberEngine, __w,
> _UIntType>& __rhs)
> { return !(__lhs == __rhs); }
># 1274 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RandomNumberEngine, size_t __w, typename _UIntType,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::independent_bits_engine<_RandomNumberEngine,
> __w, _UIntType>& __x)
> {
> __os << __x.base();
> return __os;
> }
>
>
>
>
>
>
>
> template<typename _RandomNumberEngine, size_t __k>
> class shuffle_order_engine
> {
> static_assert(1u <= __k, "template argument substituting "
> "__k out of bound");
>
> public:
>
> typedef typename _RandomNumberEngine::result_type result_type;
>
> static constexpr size_t table_size = __k;
>
>
>
>
>
>
> shuffle_order_engine()
> : _M_b()
> { _M_initialize(); }
>
>
>
>
>
>
>
> explicit
> shuffle_order_engine(const _RandomNumberEngine& __rng)
> : _M_b(__rng)
> { _M_initialize(); }
>
>
>
>
>
>
>
> explicit
> shuffle_order_engine(_RandomNumberEngine&& __rng)
> : _M_b(std::move(__rng))
> { _M_initialize(); }
>
>
>
>
>
>
>
> explicit
> shuffle_order_engine(result_type __s)
> : _M_b(__s)
> { _M_initialize(); }
>
>
>
>
>
>
> template<typename _Sseq, typename = typename
> std::enable_if<!std::is_same<_Sseq, shuffle_order_engine>::value
> && !std::is_same<_Sseq, _RandomNumberEngine>::value>
> ::type>
> explicit
> shuffle_order_engine(_Sseq& __q)
> : _M_b(__q)
> { _M_initialize(); }
>
>
>
>
>
> void
> seed()
> {
> _M_b.seed();
> _M_initialize();
> }
>
>
>
>
>
> void
> seed(result_type __s)
> {
> _M_b.seed(__s);
> _M_initialize();
> }
>
>
>
>
>
>
> template<typename _Sseq>
> void
> seed(_Sseq& __q)
> {
> _M_b.seed(__q);
> _M_initialize();
> }
>
>
>
>
> const _RandomNumberEngine&
> base() const noexcept
> { return _M_b; }
>
>
>
>
> static constexpr result_type
> min()
> { return _RandomNumberEngine::min(); }
>
>
>
>
> static constexpr result_type
> max()
> { return _RandomNumberEngine::max(); }
>
>
>
>
> void
> discard(unsigned long long __z)
> {
> for (; __z != 0ULL; --__z)
> (*this)();
> }
>
>
>
>
> result_type
> operator()();
># 1442 "/usr/include/c++/4.8.2/bits/random.h" 3
> friend bool
> operator==(const shuffle_order_engine& __lhs,
> const shuffle_order_engine& __rhs)
> { return (__lhs._M_b == __rhs._M_b
> && std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
> && __lhs._M_y == __rhs._M_y); }
># 1460 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RandomNumberEngine1, size_t __k1,
> typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::shuffle_order_engine<_RandomNumberEngine1,
> __k1>& __x);
># 1478 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RandomNumberEngine1, size_t __k1,
> typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x);
>
> private:
> void _M_initialize()
> {
> for (size_t __i = 0; __i < __k; ++__i)
> _M_v[__i] = _M_b();
> _M_y = _M_b();
> }
>
> _RandomNumberEngine _M_b;
> result_type _M_v[__k];
> result_type _M_y;
> };
># 1508 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RandomNumberEngine, size_t __k>
> inline bool
> operator!=(const std::shuffle_order_engine<_RandomNumberEngine,
> __k>& __lhs,
> const std::shuffle_order_engine<_RandomNumberEngine,
> __k>& __rhs)
> { return !(__lhs == __rhs); }
>
>
>
>
>
> typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
> minstd_rand0;
>
>
>
>
> typedef linear_congruential_engine<uint_fast32_t, 48271UL, 0UL, 2147483647UL>
> minstd_rand;
># 1537 "/usr/include/c++/4.8.2/bits/random.h" 3
> typedef mersenne_twister_engine<
> uint_fast32_t,
> 32, 624, 397, 31,
> 0x9908b0dfUL, 11,
> 0xffffffffUL, 7,
> 0x9d2c5680UL, 15,
> 0xefc60000UL, 18, 1812433253UL> mt19937;
>
>
>
>
> typedef mersenne_twister_engine<
> uint_fast64_t,
> 64, 312, 156, 31,
> 0xb5026f5aa96619e9ULL, 29,
> 0x5555555555555555ULL, 17,
> 0x71d67fffeda60000ULL, 37,
> 0xfff7eee000000000ULL, 43,
> 6364136223846793005ULL> mt19937_64;
>
> typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
> ranlux24_base;
>
> typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
> ranlux48_base;
>
> typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
>
> typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
>
> typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
>
> typedef minstd_rand0 default_random_engine;
>
>
>
>
>
> class random_device
> {
> public:
>
> typedef unsigned int result_type;
>
>
>
>
>
> explicit
> random_device(const std::string& __token = "default")
> {
> _M_init(__token);
> }
>
> ~random_device()
> { _M_fini(); }
># 1604 "/usr/include/c++/4.8.2/bits/random.h" 3
> static constexpr result_type
> min()
> { return std::numeric_limits<result_type>::min(); }
>
> static constexpr result_type
> max()
> { return std::numeric_limits<result_type>::max(); }
>
> double
> entropy() const noexcept
> { return 0.0; }
>
> result_type
> operator()()
> {
>
> return this->_M_getval();
>
>
>
> }
>
>
> random_device(const random_device&) = delete;
> void operator=(const random_device&) = delete;
>
> private:
>
> void _M_init(const std::string& __token);
> void _M_init_pretr1(const std::string& __token);
> void _M_fini();
>
> result_type _M_getval();
> result_type _M_getval_pretr1();
>
> union
> {
> FILE* _M_file;
> mt19937 _M_mt;
> };
> };
># 1665 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType = int>
> class uniform_int_distribution
> {
> static_assert(std::is_integral<_IntType>::value,
> "template argument not an integral type");
>
> public:
>
> typedef _IntType result_type;
>
> struct param_type
> {
> typedef uniform_int_distribution<_IntType> distribution_type;
>
> explicit
> param_type(_IntType __a = 0,
> _IntType __b = std::numeric_limits<_IntType>::max())
> : _M_a(__a), _M_b(__b)
> {
> ;
> }
>
> result_type
> a() const
> { return _M_a; }
>
> result_type
> b() const
> { return _M_b; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
>
> private:
> _IntType _M_a;
> _IntType _M_b;
> };
>
> public:
>
>
>
> explicit
> uniform_int_distribution(_IntType __a = 0,
> _IntType __b = std::numeric_limits<_IntType>::max())
> : _M_param(__a, __b)
> { }
>
> explicit
> uniform_int_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
>
>
> void
> reset() { }
>
> result_type
> a() const
> { return _M_param.a(); }
>
> result_type
> b() const
> { return _M_param.b(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return this->a(); }
>
>
>
>
> result_type
> max() const
> { return this->b(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
> friend bool
> operator==(const uniform_int_distribution& __d1,
> const uniform_int_distribution& __d2)
> { return __d1._M_param == __d2._M_param; }
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _IntType>
> inline bool
> operator!=(const std::uniform_int_distribution<_IntType>& __d1,
> const std::uniform_int_distribution<_IntType>& __d2)
> { return !(__d1 == __d2); }
># 1839 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>&,
> const std::uniform_int_distribution<_IntType>&);
># 1853 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>&,
> std::uniform_int_distribution<_IntType>&);
># 1866 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType = double>
> class uniform_real_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef uniform_real_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __a = _RealType(0),
> _RealType __b = _RealType(1))
> : _M_a(__a), _M_b(__b)
> {
> ;
> }
>
> result_type
> a() const
> { return _M_a; }
>
> result_type
> b() const
> { return _M_b; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
>
> private:
> _RealType _M_a;
> _RealType _M_b;
> };
>
> public:
>
>
>
>
>
>
> explicit
> uniform_real_distribution(_RealType __a = _RealType(0),
> _RealType __b = _RealType(1))
> : _M_param(__a, __b)
> { }
>
> explicit
> uniform_real_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
>
>
> void
> reset() { }
>
> result_type
> a() const
> { return _M_param.a(); }
>
> result_type
> b() const
> { return _M_param.b(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return this->a(); }
>
>
>
>
> result_type
> max() const
> { return this->b(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
> return (__aurng() * (__p.b() - __p.a())) + __p.a();
> }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
> friend bool
> operator==(const uniform_real_distribution& __d1,
> const uniform_real_distribution& __d2)
> { return __d1._M_param == __d2._M_param; }
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _IntType>
> inline bool
> operator!=(const std::uniform_real_distribution<_IntType>& __d1,
> const std::uniform_real_distribution<_IntType>& __d2)
> { return !(__d1 == __d2); }
># 2048 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>&,
> const std::uniform_real_distribution<_RealType>&);
># 2062 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>&,
> std::uniform_real_distribution<_RealType>&);
># 2084 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType = double>
> class normal_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef normal_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __mean = _RealType(0),
> _RealType __stddev = _RealType(1))
> : _M_mean(__mean), _M_stddev(__stddev)
> {
> ;
> }
>
> _RealType
> mean() const
> { return _M_mean; }
>
> _RealType
> stddev() const
> { return _M_stddev; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return (__p1._M_mean == __p2._M_mean
> && __p1._M_stddev == __p2._M_stddev); }
>
> private:
> _RealType _M_mean;
> _RealType _M_stddev;
> };
>
> public:
>
>
>
>
> explicit
> normal_distribution(result_type __mean = result_type(0),
> result_type __stddev = result_type(1))
> : _M_param(__mean, __stddev), _M_saved_available(false)
> { }
>
> explicit
> normal_distribution(const param_type& __p)
> : _M_param(__p), _M_saved_available(false)
> { }
>
>
>
>
> void
> reset()
> { _M_saved_available = false; }
>
>
>
>
> _RealType
> mean() const
> { return _M_param.mean(); }
>
>
>
>
> _RealType
> stddev() const
> { return _M_param.stddev(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return std::numeric_limits<result_type>::lowest(); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
>
> template<typename _RealType1>
> friend bool
> operator==(const std::normal_distribution<_RealType1>& __d1,
> const std::normal_distribution<_RealType1>& __d2);
># 2245 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::normal_distribution<_RealType1>& __x);
># 2260 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::normal_distribution<_RealType1>& __x);
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
> result_type _M_saved;
> bool _M_saved_available;
> };
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::normal_distribution<_RealType>& __d1,
> const std::normal_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 2297 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType = double>
> class lognormal_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef lognormal_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __m = _RealType(0),
> _RealType __s = _RealType(1))
> : _M_m(__m), _M_s(__s)
> { }
>
> _RealType
> m() const
> { return _M_m; }
>
> _RealType
> s() const
> { return _M_s; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }
>
> private:
> _RealType _M_m;
> _RealType _M_s;
> };
>
> explicit
> lognormal_distribution(_RealType __m = _RealType(0),
> _RealType __s = _RealType(1))
> : _M_param(__m, __s), _M_nd()
> { }
>
> explicit
> lognormal_distribution(const param_type& __p)
> : _M_param(__p), _M_nd()
> { }
>
>
>
>
> void
> reset()
> { _M_nd.reset(); }
>
>
>
>
> _RealType
> m() const
> { return _M_param.m(); }
>
> _RealType
> s() const
> { return _M_param.s(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
>
> friend bool
> operator==(const lognormal_distribution& __d1,
> const lognormal_distribution& __d2)
> { return (__d1._M_param == __d2._M_param
> && __d1._M_nd == __d2._M_nd); }
># 2449 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::lognormal_distribution<_RealType1>& __x);
># 2464 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::lognormal_distribution<_RealType1>& __x);
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
>
> std::normal_distribution<result_type> _M_nd;
> };
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::lognormal_distribution<_RealType>& __d1,
> const std::lognormal_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 2501 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType = double>
> class gamma_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef gamma_distribution<_RealType> distribution_type;
> friend class gamma_distribution<_RealType>;
>
> explicit
> param_type(_RealType __alpha_val = _RealType(1),
> _RealType __beta_val = _RealType(1))
> : _M_alpha(__alpha_val), _M_beta(__beta_val)
> {
> ;
> _M_initialize();
> }
>
> _RealType
> alpha() const
> { return _M_alpha; }
>
> _RealType
> beta() const
> { return _M_beta; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return (__p1._M_alpha == __p2._M_alpha
> && __p1._M_beta == __p2._M_beta); }
>
> private:
> void
> _M_initialize();
>
> _RealType _M_alpha;
> _RealType _M_beta;
>
> _RealType _M_malpha, _M_a2;
> };
>
> public:
>
>
>
>
> explicit
> gamma_distribution(_RealType __alpha_val = _RealType(1),
> _RealType __beta_val = _RealType(1))
> : _M_param(__alpha_val, __beta_val), _M_nd()
> { }
>
> explicit
> gamma_distribution(const param_type& __p)
> : _M_param(__p), _M_nd()
> { }
>
>
>
>
> void
> reset()
> { _M_nd.reset(); }
>
>
>
>
> _RealType
> alpha() const
> { return _M_param.alpha(); }
>
>
>
>
> _RealType
> beta() const
> { return _M_param.beta(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
>
> friend bool
> operator==(const gamma_distribution& __d1,
> const gamma_distribution& __d2)
> { return (__d1._M_param == __d2._M_param
> && __d1._M_nd == __d2._M_nd); }
># 2670 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::gamma_distribution<_RealType1>& __x);
># 2684 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::gamma_distribution<_RealType1>& __x);
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
>
> std::normal_distribution<result_type> _M_nd;
> };
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::gamma_distribution<_RealType>& __d1,
> const std::gamma_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 2718 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType = double>
> class chi_squared_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef chi_squared_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __n = _RealType(1))
> : _M_n(__n)
> { }
>
> _RealType
> n() const
> { return _M_n; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_n == __p2._M_n; }
>
> private:
> _RealType _M_n;
> };
>
> explicit
> chi_squared_distribution(_RealType __n = _RealType(1))
> : _M_param(__n), _M_gd(__n / 2)
> { }
>
> explicit
> chi_squared_distribution(const param_type& __p)
> : _M_param(__p), _M_gd(__p.n() / 2)
> { }
>
>
>
>
> void
> reset()
> { _M_gd.reset(); }
>
>
>
>
> _RealType
> n() const
> { return _M_param.n(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return 2 * _M_gd(__urng); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> typedef typename std::gamma_distribution<result_type>::param_type
> param_type;
> return 2 * _M_gd(__urng, param_type(__p.n() / 2));
> }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate_impl(__f, __t, __urng); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { typename std::gamma_distribution<result_type>::param_type
> __p2(__p.n() / 2);
> this->__generate_impl(__f, __t, __urng, __p2); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate_impl(__f, __t, __urng); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { typename std::gamma_distribution<result_type>::param_type
> __p2(__p.n() / 2);
> this->__generate_impl(__f, __t, __urng, __p2); }
>
>
>
>
>
>
> friend bool
> operator==(const chi_squared_distribution& __d1,
> const chi_squared_distribution& __d2)
> { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
># 2872 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::chi_squared_distribution<_RealType1>& __x);
># 2887 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::chi_squared_distribution<_RealType1>& __x);
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const typename
> std::gamma_distribution<result_type>::param_type& __p);
>
> param_type _M_param;
>
> std::gamma_distribution<result_type> _M_gd;
> };
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::chi_squared_distribution<_RealType>& __d1,
> const std::chi_squared_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 2928 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType = double>
> class cauchy_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef cauchy_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __a = _RealType(0),
> _RealType __b = _RealType(1))
> : _M_a(__a), _M_b(__b)
> { }
>
> _RealType
> a() const
> { return _M_a; }
>
> _RealType
> b() const
> { return _M_b; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
>
> private:
> _RealType _M_a;
> _RealType _M_b;
> };
>
> explicit
> cauchy_distribution(_RealType __a = _RealType(0),
> _RealType __b = _RealType(1))
> : _M_param(__a, __b)
> { }
>
> explicit
> cauchy_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
> void
> reset()
> { }
>
>
>
>
> _RealType
> a() const
> { return _M_param.a(); }
>
> _RealType
> b() const
> { return _M_param.b(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return std::numeric_limits<result_type>::lowest(); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
> friend bool
> operator==(const cauchy_distribution& __d1,
> const cauchy_distribution& __d2)
> { return __d1._M_param == __d2._M_param; }
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::cauchy_distribution<_RealType>& __d1,
> const std::cauchy_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 3098 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::cauchy_distribution<_RealType>& __x);
># 3113 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::cauchy_distribution<_RealType>& __x);
># 3129 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType = double>
> class fisher_f_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef fisher_f_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __m = _RealType(1),
> _RealType __n = _RealType(1))
> : _M_m(__m), _M_n(__n)
> { }
>
> _RealType
> m() const
> { return _M_m; }
>
> _RealType
> n() const
> { return _M_n; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }
>
> private:
> _RealType _M_m;
> _RealType _M_n;
> };
>
> explicit
> fisher_f_distribution(_RealType __m = _RealType(1),
> _RealType __n = _RealType(1))
> : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
> { }
>
> explicit
> fisher_f_distribution(const param_type& __p)
> : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
> { }
>
>
>
>
> void
> reset()
> {
> _M_gd_x.reset();
> _M_gd_y.reset();
> }
>
>
>
>
> _RealType
> m() const
> { return _M_param.m(); }
>
> _RealType
> n() const
> { return _M_param.n(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> typedef typename std::gamma_distribution<result_type>::param_type
> param_type;
> return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
> / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
> }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate_impl(__f, __t, __urng); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate_impl(__f, __t, __urng); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
>
> friend bool
> operator==(const fisher_f_distribution& __d1,
> const fisher_f_distribution& __d2)
> { return (__d1._M_param == __d2._M_param
> && __d1._M_gd_x == __d2._M_gd_x
> && __d1._M_gd_y == __d2._M_gd_y); }
># 3296 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::fisher_f_distribution<_RealType1>& __x);
># 3311 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::fisher_f_distribution<_RealType1>& __x);
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
>
> std::gamma_distribution<result_type> _M_gd_x, _M_gd_y;
> };
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::fisher_f_distribution<_RealType>& __d1,
> const std::fisher_f_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 3353 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType = double>
> class student_t_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef student_t_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __n = _RealType(1))
> : _M_n(__n)
> { }
>
> _RealType
> n() const
> { return _M_n; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_n == __p2._M_n; }
>
> private:
> _RealType _M_n;
> };
>
> explicit
> student_t_distribution(_RealType __n = _RealType(1))
> : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
> { }
>
> explicit
> student_t_distribution(const param_type& __p)
> : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
> { }
>
>
>
>
> void
> reset()
> {
> _M_nd.reset();
> _M_gd.reset();
> }
>
>
>
>
> _RealType
> n() const
> { return _M_param.n(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return std::numeric_limits<result_type>::lowest(); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng)); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> typedef typename std::gamma_distribution<result_type>::param_type
> param_type;
>
> const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
> return _M_nd(__urng) * std::sqrt(__p.n() / __g);
> }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate_impl(__f, __t, __urng); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate_impl(__f, __t, __urng); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
>
> friend bool
> operator==(const student_t_distribution& __d1,
> const student_t_distribution& __d2)
> { return (__d1._M_param == __d2._M_param
> && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
># 3509 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::student_t_distribution<_RealType1>& __x);
># 3524 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::student_t_distribution<_RealType1>& __x);
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng);
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
>
> std::normal_distribution<result_type> _M_nd;
> std::gamma_distribution<result_type> _M_gd;
> };
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::student_t_distribution<_RealType>& __d1,
> const std::student_t_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 3572 "/usr/include/c++/4.8.2/bits/random.h" 3
> class bernoulli_distribution
> {
> public:
>
> typedef bool result_type;
>
> struct param_type
> {
> typedef bernoulli_distribution distribution_type;
>
> explicit
> param_type(double __p = 0.5)
> : _M_p(__p)
> {
> ;
> }
>
> double
> p() const
> { return _M_p; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_p == __p2._M_p; }
>
> private:
> double _M_p;
> };
>
> public:
>
>
>
>
>
>
> explicit
> bernoulli_distribution(double __p = 0.5)
> : _M_param(__p)
> { }
>
> explicit
> bernoulli_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
>
>
> void
> reset() { }
>
>
>
>
> double
> p() const
> { return _M_param.p(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return std::numeric_limits<result_type>::min(); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
> if ((__aurng() - __aurng.min())
> < __p.p() * (__aurng.max() - __aurng.min()))
> return true;
> return false;
> }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng, const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
> friend bool
> operator==(const bernoulli_distribution& __d1,
> const bernoulli_distribution& __d2)
> { return __d1._M_param == __d2._M_param; }
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
> };
>
>
>
>
>
> inline bool
> operator!=(const std::bernoulli_distribution& __d1,
> const std::bernoulli_distribution& __d2)
> { return !(__d1 == __d2); }
># 3743 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::bernoulli_distribution& __x);
># 3757 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::bernoulli_distribution& __x)
> {
> double __p;
> __is >> __p;
> __x.param(bernoulli_distribution::param_type(__p));
> return __is;
> }
># 3776 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType = int>
> class binomial_distribution
> {
> static_assert(std::is_integral<_IntType>::value,
> "template argument not an integral type");
>
> public:
>
> typedef _IntType result_type;
>
> struct param_type
> {
> typedef binomial_distribution<_IntType> distribution_type;
> friend class binomial_distribution<_IntType>;
>
> explicit
> param_type(_IntType __t = _IntType(1), double __p = 0.5)
> : _M_t(__t), _M_p(__p)
> {
> 
>
> ;
> _M_initialize();
> }
>
> _IntType
> t() const
> { return _M_t; }
>
> double
> p() const
> { return _M_p; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
>
> private:
> void
> _M_initialize();
>
> _IntType _M_t;
> double _M_p;
>
> double _M_q;
>
> double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
> _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
>
> bool _M_easy;
> };
>
>
> explicit
> binomial_distribution(_IntType __t = _IntType(1),
> double __p = 0.5)
> : _M_param(__t, __p), _M_nd()
> { }
>
> explicit
> binomial_distribution(const param_type& __p)
> : _M_param(__p), _M_nd()
> { }
>
>
>
>
> void
> reset()
> { _M_nd.reset(); }
>
>
>
>
> _IntType
> t() const
> { return _M_param.t(); }
>
>
>
>
> double
> p() const
> { return _M_param.p(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return 0; }
>
>
>
>
> result_type
> max() const
> { return _M_param.t(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
>
> friend bool
> operator==(const binomial_distribution& __d1,
> const binomial_distribution& __d2)
>
> { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
># 3949 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType1,
> typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::binomial_distribution<_IntType1>& __x);
># 3965 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType1,
> typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::binomial_distribution<_IntType1>& __x);
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> _M_waiting(_UniformRandomNumberGenerator& __urng,
> _IntType __t, double __q);
>
> param_type _M_param;
>
>
> std::normal_distribution<double> _M_nd;
> };
>
>
>
>
> template<typename _IntType>
> inline bool
> operator!=(const std::binomial_distribution<_IntType>& __d1,
> const std::binomial_distribution<_IntType>& __d2)
> { return !(__d1 == __d2); }
># 4007 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType = int>
> class geometric_distribution
> {
> static_assert(std::is_integral<_IntType>::value,
> "template argument not an integral type");
>
> public:
>
> typedef _IntType result_type;
>
> struct param_type
> {
> typedef geometric_distribution<_IntType> distribution_type;
> friend class geometric_distribution<_IntType>;
>
> explicit
> param_type(double __p = 0.5)
> : _M_p(__p)
> {
> ;
> _M_initialize();
> }
>
> double
> p() const
> { return _M_p; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_p == __p2._M_p; }
>
> private:
> void
> _M_initialize()
> { _M_log_1_p = std::log(1.0 - _M_p); }
>
> double _M_p;
>
> double _M_log_1_p;
> };
>
>
> explicit
> geometric_distribution(double __p = 0.5)
> : _M_param(__p)
> { }
>
> explicit
> geometric_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
>
>
> void
> reset() { }
>
>
>
>
> double
> p() const
> { return _M_param.p(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return 0; }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
> friend bool
> operator==(const geometric_distribution& __d1,
> const geometric_distribution& __d2)
> { return __d1._M_param == __d2._M_param; }
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _IntType>
> inline bool
> operator!=(const std::geometric_distribution<_IntType>& __d1,
> const std::geometric_distribution<_IntType>& __d2)
> { return !(__d1 == __d2); }
># 4178 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::geometric_distribution<_IntType>& __x);
># 4193 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::geometric_distribution<_IntType>& __x);
># 4207 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType = int>
> class negative_binomial_distribution
> {
> static_assert(std::is_integral<_IntType>::value,
> "template argument not an integral type");
>
> public:
>
> typedef _IntType result_type;
>
> struct param_type
> {
> typedef negative_binomial_distribution<_IntType> distribution_type;
>
> explicit
> param_type(_IntType __k = 1, double __p = 0.5)
> : _M_k(__k), _M_p(__p)
> {
> ;
> }
>
> _IntType
> k() const
> { return _M_k; }
>
> double
> p() const
> { return _M_p; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
>
> private:
> _IntType _M_k;
> double _M_p;
> };
>
> explicit
> negative_binomial_distribution(_IntType __k = 1, double __p = 0.5)
> : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
> { }
>
> explicit
> negative_binomial_distribution(const param_type& __p)
> : _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p())
> { }
>
>
>
>
> void
> reset()
> { _M_gd.reset(); }
>
>
>
>
> _IntType
> k() const
> { return _M_param.k(); }
>
>
>
>
> double
> p() const
> { return _M_param.p(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng);
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate_impl(__f, __t, __urng); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate_impl(__f, __t, __urng); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
>
> friend bool
> operator==(const negative_binomial_distribution& __d1,
> const negative_binomial_distribution& __d2)
> { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
># 4366 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::negative_binomial_distribution<_IntType1>& __x);
># 4381 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::negative_binomial_distribution<_IntType1>& __x);
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng);
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
>
> std::gamma_distribution<double> _M_gd;
> };
>
>
>
>
> template<typename _IntType>
> inline bool
> operator!=(const std::negative_binomial_distribution<_IntType>& __d1,
> const std::negative_binomial_distribution<_IntType>& __d2)
> { return !(__d1 == __d2); }
># 4429 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType = int>
> class poisson_distribution
> {
> static_assert(std::is_integral<_IntType>::value,
> "template argument not an integral type");
>
> public:
>
> typedef _IntType result_type;
>
> struct param_type
> {
> typedef poisson_distribution<_IntType> distribution_type;
> friend class poisson_distribution<_IntType>;
>
> explicit
> param_type(double __mean = 1.0)
> : _M_mean(__mean)
> {
> ;
> _M_initialize();
> }
>
> double
> mean() const
> { return _M_mean; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_mean == __p2._M_mean; }
>
> private:
>
> void
> _M_initialize();
>
> double _M_mean;
>
> double _M_lm_thr;
>
> double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
>
> };
>
>
> explicit
> poisson_distribution(double __mean = 1.0)
> : _M_param(__mean), _M_nd()
> { }
>
> explicit
> poisson_distribution(const param_type& __p)
> : _M_param(__p), _M_nd()
> { }
>
>
>
>
> void
> reset()
> { _M_nd.reset(); }
>
>
>
>
> double
> mean() const
> { return _M_param.mean(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return 0; }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
>
> friend bool
> operator==(const poisson_distribution& __d1,
> const poisson_distribution& __d2)
>
> { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
># 4586 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::poisson_distribution<_IntType1>& __x);
># 4601 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::poisson_distribution<_IntType1>& __x);
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
>
>
> std::normal_distribution<double> _M_nd;
> };
>
>
>
>
> template<typename _IntType>
> inline bool
> operator!=(const std::poisson_distribution<_IntType>& __d1,
> const std::poisson_distribution<_IntType>& __d2)
> { return !(__d1 == __d2); }
># 4645 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType = double>
> class exponential_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef exponential_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __lambda = _RealType(1))
> : _M_lambda(__lambda)
> {
> ;
> }
>
> _RealType
> lambda() const
> { return _M_lambda; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_lambda == __p2._M_lambda; }
>
> private:
> _RealType _M_lambda;
> };
>
> public:
>
>
>
>
> explicit
> exponential_distribution(const result_type& __lambda = result_type(1))
> : _M_param(__lambda)
> { }
>
> explicit
> exponential_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
>
>
> void
> reset() { }
>
>
>
>
> _RealType
> lambda() const
> { return _M_param.lambda(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
> return -std::log(result_type(1) - __aurng()) / __p.lambda();
> }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
> friend bool
> operator==(const exponential_distribution& __d1,
> const exponential_distribution& __d2)
> { return __d1._M_param == __d2._M_param; }
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::exponential_distribution<_RealType>& __d1,
> const std::exponential_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 4817 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::exponential_distribution<_RealType>& __x);
># 4832 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::exponential_distribution<_RealType>& __x);
># 4847 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType = double>
> class weibull_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef weibull_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __a = _RealType(1),
> _RealType __b = _RealType(1))
> : _M_a(__a), _M_b(__b)
> { }
>
> _RealType
> a() const
> { return _M_a; }
>
> _RealType
> b() const
> { return _M_b; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
>
> private:
> _RealType _M_a;
> _RealType _M_b;
> };
>
> explicit
> weibull_distribution(_RealType __a = _RealType(1),
> _RealType __b = _RealType(1))
> : _M_param(__a, __b)
> { }
>
> explicit
> weibull_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
> void
> reset()
> { }
>
>
>
>
> _RealType
> a() const
> { return _M_param.a(); }
>
>
>
>
> _RealType
> b() const
> { return _M_param.b(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
> friend bool
> operator==(const weibull_distribution& __d1,
> const weibull_distribution& __d2)
> { return __d1._M_param == __d2._M_param; }
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::weibull_distribution<_RealType>& __d1,
> const std::weibull_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 5020 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::weibull_distribution<_RealType>& __x);
># 5035 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::weibull_distribution<_RealType>& __x);
># 5050 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType = double>
> class extreme_value_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef extreme_value_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __a = _RealType(0),
> _RealType __b = _RealType(1))
> : _M_a(__a), _M_b(__b)
> { }
>
> _RealType
> a() const
> { return _M_a; }
>
> _RealType
> b() const
> { return _M_b; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
>
> private:
> _RealType _M_a;
> _RealType _M_b;
> };
>
> explicit
> extreme_value_distribution(_RealType __a = _RealType(0),
> _RealType __b = _RealType(1))
> : _M_param(__a, __b)
> { }
>
> explicit
> extreme_value_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
> void
> reset()
> { }
>
>
>
>
> _RealType
> a() const
> { return _M_param.a(); }
>
>
>
>
> _RealType
> b() const
> { return _M_param.b(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return std::numeric_limits<result_type>::lowest(); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
> friend bool
> operator==(const extreme_value_distribution& __d1,
> const extreme_value_distribution& __d2)
> { return __d1._M_param == __d2._M_param; }
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::extreme_value_distribution<_RealType>& __d1,
> const std::extreme_value_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 5223 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::extreme_value_distribution<_RealType>& __x);
># 5238 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::extreme_value_distribution<_RealType>& __x);
># 5250 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType = int>
> class discrete_distribution
> {
> static_assert(std::is_integral<_IntType>::value,
> "template argument not an integral type");
>
> public:
>
> typedef _IntType result_type;
>
> struct param_type
> {
> typedef discrete_distribution<_IntType> distribution_type;
> friend class discrete_distribution<_IntType>;
>
> param_type()
> : _M_prob(), _M_cp()
> { }
>
> template<typename _InputIterator>
> param_type(_InputIterator __wbegin,
> _InputIterator __wend)
> : _M_prob(__wbegin, __wend), _M_cp()
> { _M_initialize(); }
>
> param_type(initializer_list<double> __wil)
> : _M_prob(__wil.begin(), __wil.end()), _M_cp()
> { _M_initialize(); }
>
> template<typename _Func>
> param_type(size_t __nw, double __xmin, double __xmax,
> _Func __fw);
>
>
> param_type(const param_type&) = default;
> param_type& operator=(const param_type&) = default;
>
> std::vector<double>
> probabilities() const
> { return _M_prob.empty() ? std::vector<double>(1, 1.0) : _M_prob; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_prob == __p2._M_prob; }
>
> private:
> void
> _M_initialize();
>
> std::vector<double> _M_prob;
> std::vector<double> _M_cp;
> };
>
> discrete_distribution()
> : _M_param()
> { }
>
> template<typename _InputIterator>
> discrete_distribution(_InputIterator __wbegin,
> _InputIterator __wend)
> : _M_param(__wbegin, __wend)
> { }
>
> discrete_distribution(initializer_list<double> __wl)
> : _M_param(__wl)
> { }
>
> template<typename _Func>
> discrete_distribution(size_t __nw, double __xmin, double __xmax,
> _Func __fw)
> : _M_param(__nw, __xmin, __xmax, __fw)
> { }
>
> explicit
> discrete_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
> void
> reset()
> { }
>
>
>
>
> std::vector<double>
> probabilities() const
> {
> return _M_param._M_prob.empty()
> ? std::vector<double>(1, 1.0) : _M_param._M_prob;
> }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> {
> return _M_param._M_prob.empty()
> ? result_type(0) : result_type(_M_param._M_prob.size() - 1);
> }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
> friend bool
> operator==(const discrete_distribution& __d1,
> const discrete_distribution& __d2)
> { return __d1._M_param == __d2._M_param; }
># 5431 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::discrete_distribution<_IntType1>& __x);
># 5447 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _IntType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::discrete_distribution<_IntType1>& __x);
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _IntType>
> inline bool
> operator!=(const std::discrete_distribution<_IntType>& __d1,
> const std::discrete_distribution<_IntType>& __d2)
> { return !(__d1 == __d2); }
># 5480 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType = double>
> class piecewise_constant_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef piecewise_constant_distribution<_RealType> distribution_type;
> friend class piecewise_constant_distribution<_RealType>;
>
> param_type()
> : _M_int(), _M_den(), _M_cp()
> { }
>
> template<typename _InputIteratorB, typename _InputIteratorW>
> param_type(_InputIteratorB __bfirst,
> _InputIteratorB __bend,
> _InputIteratorW __wbegin);
>
> template<typename _Func>
> param_type(initializer_list<_RealType> __bi, _Func __fw);
>
> template<typename _Func>
> param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
> _Func __fw);
>
>
> param_type(const param_type&) = default;
> param_type& operator=(const param_type&) = default;
>
> std::vector<_RealType>
> intervals() const
> {
> if (_M_int.empty())
> {
> std::vector<_RealType> __tmp(2);
> __tmp[1] = _RealType(1);
> return __tmp;
> }
> else
> return _M_int;
> }
>
> std::vector<double>
> densities() const
> { return _M_den.empty() ? std::vector<double>(1, 1.0) : _M_den; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
>
> private:
> void
> _M_initialize();
>
> std::vector<_RealType> _M_int;
> std::vector<double> _M_den;
> std::vector<double> _M_cp;
> };
>
> explicit
> piecewise_constant_distribution()
> : _M_param()
> { }
>
> template<typename _InputIteratorB, typename _InputIteratorW>
> piecewise_constant_distribution(_InputIteratorB __bfirst,
> _InputIteratorB __bend,
> _InputIteratorW __wbegin)
> : _M_param(__bfirst, __bend, __wbegin)
> { }
>
> template<typename _Func>
> piecewise_constant_distribution(initializer_list<_RealType> __bl,
> _Func __fw)
> : _M_param(__bl, __fw)
> { }
>
> template<typename _Func>
> piecewise_constant_distribution(size_t __nw,
> _RealType __xmin, _RealType __xmax,
> _Func __fw)
> : _M_param(__nw, __xmin, __xmax, __fw)
> { }
>
> explicit
> piecewise_constant_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
> void
> reset()
> { }
>
>
>
>
> std::vector<_RealType>
> intervals() const
> {
> if (_M_param._M_int.empty())
> {
> std::vector<_RealType> __tmp(2);
> __tmp[1] = _RealType(1);
> return __tmp;
> }
> else
> return _M_param._M_int;
> }
>
>
>
>
> std::vector<double>
> densities() const
> {
> return _M_param._M_den.empty()
> ? std::vector<double>(1, 1.0) : _M_param._M_den;
> }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> {
> return _M_param._M_int.empty()
> ? result_type(0) : _M_param._M_int.front();
> }
>
>
>
>
> result_type
> max() const
> {
> return _M_param._M_int.empty()
> ? result_type(1) : _M_param._M_int.back();
> }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
> friend bool
> operator==(const piecewise_constant_distribution& __d1,
> const piecewise_constant_distribution& __d2)
> { return __d1._M_param == __d2._M_param; }
># 5698 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::piecewise_constant_distribution<_RealType1>& __x);
># 5714 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::piecewise_constant_distribution<_RealType1>& __x);
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::piecewise_constant_distribution<_RealType>& __d1,
> const std::piecewise_constant_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 5747 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType = double>
> class piecewise_linear_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef piecewise_linear_distribution<_RealType> distribution_type;
> friend class piecewise_linear_distribution<_RealType>;
>
> param_type()
> : _M_int(), _M_den(), _M_cp(), _M_m()
> { }
>
> template<typename _InputIteratorB, typename _InputIteratorW>
> param_type(_InputIteratorB __bfirst,
> _InputIteratorB __bend,
> _InputIteratorW __wbegin);
>
> template<typename _Func>
> param_type(initializer_list<_RealType> __bl, _Func __fw);
>
> template<typename _Func>
> param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
> _Func __fw);
>
>
> param_type(const param_type&) = default;
> param_type& operator=(const param_type&) = default;
>
> std::vector<_RealType>
> intervals() const
> {
> if (_M_int.empty())
> {
> std::vector<_RealType> __tmp(2);
> __tmp[1] = _RealType(1);
> return __tmp;
> }
> else
> return _M_int;
> }
>
> std::vector<double>
> densities() const
> { return _M_den.empty() ? std::vector<double>(2, 1.0) : _M_den; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return (__p1._M_int == __p2._M_int
> && __p1._M_den == __p2._M_den); }
>
> private:
> void
> _M_initialize();
>
> std::vector<_RealType> _M_int;
> std::vector<double> _M_den;
> std::vector<double> _M_cp;
> std::vector<double> _M_m;
> };
>
> explicit
> piecewise_linear_distribution()
> : _M_param()
> { }
>
> template<typename _InputIteratorB, typename _InputIteratorW>
> piecewise_linear_distribution(_InputIteratorB __bfirst,
> _InputIteratorB __bend,
> _InputIteratorW __wbegin)
> : _M_param(__bfirst, __bend, __wbegin)
> { }
>
> template<typename _Func>
> piecewise_linear_distribution(initializer_list<_RealType> __bl,
> _Func __fw)
> : _M_param(__bl, __fw)
> { }
>
> template<typename _Func>
> piecewise_linear_distribution(size_t __nw,
> _RealType __xmin, _RealType __xmax,
> _Func __fw)
> : _M_param(__nw, __xmin, __xmax, __fw)
> { }
>
> explicit
> piecewise_linear_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
> void
> reset()
> { }
>
>
>
>
> std::vector<_RealType>
> intervals() const
> {
> if (_M_param._M_int.empty())
> {
> std::vector<_RealType> __tmp(2);
> __tmp[1] = _RealType(1);
> return __tmp;
> }
> else
> return _M_param._M_int;
> }
>
>
>
>
>
> std::vector<double>
> densities() const
> {
> return _M_param._M_den.empty()
> ? std::vector<double>(2, 1.0) : _M_param._M_den;
> }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> {
> return _M_param._M_int.empty()
> ? result_type(0) : _M_param._M_int.front();
> }
>
>
>
>
> result_type
> max() const
> {
> return _M_param._M_int.empty()
> ? result_type(1) : _M_param._M_int.back();
> }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
> friend bool
> operator==(const piecewise_linear_distribution& __d1,
> const piecewise_linear_distribution& __d2)
> { return __d1._M_param == __d2._M_param; }
># 5968 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::piecewise_linear_distribution<_RealType1>& __x);
># 5984 "/usr/include/c++/4.8.2/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::piecewise_linear_distribution<_RealType1>& __x);
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::piecewise_linear_distribution<_RealType>& __d1,
> const std::piecewise_linear_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 6025 "/usr/include/c++/4.8.2/bits/random.h" 3
> class seed_seq
> {
>
> public:
>
> typedef uint_least32_t result_type;
>
>
> seed_seq()
> : _M_v()
> { }
>
> template<typename _IntType>
> seed_seq(std::initializer_list<_IntType> il);
>
> template<typename _InputIterator>
> seed_seq(_InputIterator __begin, _InputIterator __end);
>
>
> template<typename _RandomAccessIterator>
> void
> generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
>
>
> size_t size() const
> { return _M_v.size(); }
>
> template<typename OutputIterator>
> void
> param(OutputIterator __dest) const
> { std::copy(_M_v.begin(), _M_v.end(), __dest); }
>
> private:
>
> std::vector<result_type> _M_v;
> };
>
>
>
>
>
>
>}
># 51 "/usr/include/c++/4.8.2/random" 2 3
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/opt_random.h" 1 3
># 33 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/opt_random.h" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/x86intrin.h" 1 3 4
># 27 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/x86intrin.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/ia32intrin.h" 1 3 4
># 29 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/ia32intrin.h" 3 4
>extern __inline int
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__bsfd (int __X)
>{
> return __builtin_ctz (__X);
>}
>
>
>extern __inline int
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__bsrd (int __X)
>{
> return __builtin_ia32_bsrsi (__X);
>}
>
>
>extern __inline int
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__bswapd (int __X)
>{
> return __builtin_bswap32 (__X);
>}
># 77 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/ia32intrin.h" 3 4
>extern __inline int
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__popcntd (unsigned int __X)
>{
> return __builtin_popcount (__X);
>}
>
>
>extern __inline unsigned long long
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__rdpmc (int __S)
>{
> return __builtin_ia32_rdpmc (__S);
>}
>
>
>extern __inline unsigned long long
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__rdtsc (void)
>{
> return __builtin_ia32_rdtsc ();
>}
>
>
>extern __inline unsigned long long
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__rdtscp (unsigned int *__A)
>{
> return __builtin_ia32_rdtscp (__A);
>}
>
>
>extern __inline unsigned char
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__rolb (unsigned char __X, int __C)
>{
> return __builtin_ia32_rolqi (__X, __C);
>}
>
>
>extern __inline unsigned short
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__rolw (unsigned short __X, int __C)
>{
> return __builtin_ia32_rolhi (__X, __C);
>}
>
>
>extern __inline unsigned int
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__rold (unsigned int __X, int __C)
>{
> return (__X << __C) | (__X >> (32 - __C));
>}
>
>
>extern __inline unsigned char
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__rorb (unsigned char __X, int __C)
>{
> return __builtin_ia32_rorqi (__X, __C);
>}
>
>
>extern __inline unsigned short
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__rorw (unsigned short __X, int __C)
>{
> return __builtin_ia32_rorhi (__X, __C);
>}
>
>
>extern __inline unsigned int
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__rord (unsigned int __X, int __C)
>{
> return (__X >> __C) | (__X << (32 - __C));
>}
>
>
>extern __inline void
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__pause (void)
>{
> __builtin_ia32_pause ();
>}
>
>
>
>extern __inline int
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__bsfq (long long __X)
>{
> return __builtin_ctzll (__X);
>}
>
>
>extern __inline int
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__bsrq (long long __X)
>{
> return __builtin_ia32_bsrdi (__X);
>}
>
>
>extern __inline long long
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__bswapq (long long __X)
>{
> return __builtin_bswap64 (__X);
>}
># 200 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/ia32intrin.h" 3 4
>extern __inline long long
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__popcntq (unsigned long long __X)
>{
> return __builtin_popcountll (__X);
>}
>
>
>extern __inline unsigned long long
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__rolq (unsigned long long __X, int __C)
>{
> return (__X << __C) | (__X >> (64 - __C));
>}
>
>
>extern __inline unsigned long long
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>__rorq (unsigned long long __X, int __C)
>{
> return (__X >> __C) | (__X << (64 - __C));
>}
># 28 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/x86intrin.h" 2 3 4
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/mmintrin.h" 1 3 4
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/mmintrin.h" 3 4
>typedef int __m64 __attribute__ ((__vector_size__ (8), __may_alias__));
>
>
>typedef int __v2si __attribute__ ((__vector_size__ (8)));
>typedef short __v4hi __attribute__ ((__vector_size__ (8)));
>typedef char __v8qi __attribute__ ((__vector_size__ (8)));
>typedef long long __v1di __attribute__ ((__vector_size__ (8)));
>typedef float __v2sf __attribute__ ((__vector_size__ (8)));
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_empty (void)
>{
> __builtin_ia32_emms ();
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_empty (void)
>{
> _mm_empty ();
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi32_si64 (int __i)
>{
> return (__m64) __builtin_ia32_vec_init_v2si (__i, 0);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_from_int (int __i)
>{
> return _mm_cvtsi32_si64 (__i);
>}
>
>
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_from_int64 (long long __i)
>{
> return (__m64) __i;
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi64_m64 (long long __i)
>{
> return (__m64) __i;
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi64x_si64 (long long __i)
>{
> return (__m64) __i;
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set_pi64x (long long __i)
>{
> return (__m64) __i;
>}
>
>
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi64_si32 (__m64 __i)
>{
> return __builtin_ia32_vec_ext_v2si ((__v2si)__i, 0);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_to_int (__m64 __i)
>{
> return _mm_cvtsi64_si32 (__i);
>}
>
>
>
>
>
>extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_to_int64 (__m64 __i)
>{
> return (long long)__i;
>}
>
>extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtm64_si64 (__m64 __i)
>{
> return (long long)__i;
>}
>
>
>extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi64_si64x (__m64 __i)
>{
> return (long long)__i;
>}
>
>
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_packs_pi16 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_packsswb ((__v4hi)__m1, (__v4hi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_packsswb (__m64 __m1, __m64 __m2)
>{
> return _mm_packs_pi16 (__m1, __m2);
>}
>
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_packs_pi32 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_packssdw ((__v2si)__m1, (__v2si)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_packssdw (__m64 __m1, __m64 __m2)
>{
> return _mm_packs_pi32 (__m1, __m2);
>}
>
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_packs_pu16 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_packuswb ((__v4hi)__m1, (__v4hi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_packuswb (__m64 __m1, __m64 __m2)
>{
> return _mm_packs_pu16 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpackhi_pi8 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_punpckhbw ((__v8qi)__m1, (__v8qi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_punpckhbw (__m64 __m1, __m64 __m2)
>{
> return _mm_unpackhi_pi8 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpackhi_pi16 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_punpckhwd ((__v4hi)__m1, (__v4hi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_punpckhwd (__m64 __m1, __m64 __m2)
>{
> return _mm_unpackhi_pi16 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpackhi_pi32 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_punpckhdq ((__v2si)__m1, (__v2si)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_punpckhdq (__m64 __m1, __m64 __m2)
>{
> return _mm_unpackhi_pi32 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpacklo_pi8 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_punpcklbw ((__v8qi)__m1, (__v8qi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_punpcklbw (__m64 __m1, __m64 __m2)
>{
> return _mm_unpacklo_pi8 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpacklo_pi16 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_punpcklwd ((__v4hi)__m1, (__v4hi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_punpcklwd (__m64 __m1, __m64 __m2)
>{
> return _mm_unpacklo_pi16 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpacklo_pi32 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_punpckldq ((__v2si)__m1, (__v2si)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_punpckldq (__m64 __m1, __m64 __m2)
>{
> return _mm_unpacklo_pi32 (__m1, __m2);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_add_pi8 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_paddb ((__v8qi)__m1, (__v8qi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_paddb (__m64 __m1, __m64 __m2)
>{
> return _mm_add_pi8 (__m1, __m2);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_add_pi16 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_paddw ((__v4hi)__m1, (__v4hi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_paddw (__m64 __m1, __m64 __m2)
>{
> return _mm_add_pi16 (__m1, __m2);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_add_pi32 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_paddd ((__v2si)__m1, (__v2si)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_paddd (__m64 __m1, __m64 __m2)
>{
> return _mm_add_pi32 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_add_si64 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_paddq ((__v1di)__m1, (__v1di)__m2);
>}
>
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_adds_pi8 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_paddsb ((__v8qi)__m1, (__v8qi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_paddsb (__m64 __m1, __m64 __m2)
>{
> return _mm_adds_pi8 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_adds_pi16 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_paddsw ((__v4hi)__m1, (__v4hi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_paddsw (__m64 __m1, __m64 __m2)
>{
> return _mm_adds_pi16 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_adds_pu8 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_paddusb ((__v8qi)__m1, (__v8qi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_paddusb (__m64 __m1, __m64 __m2)
>{
> return _mm_adds_pu8 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_adds_pu16 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_paddusw ((__v4hi)__m1, (__v4hi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_paddusw (__m64 __m1, __m64 __m2)
>{
> return _mm_adds_pu16 (__m1, __m2);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sub_pi8 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_psubb ((__v8qi)__m1, (__v8qi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psubb (__m64 __m1, __m64 __m2)
>{
> return _mm_sub_pi8 (__m1, __m2);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sub_pi16 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_psubw ((__v4hi)__m1, (__v4hi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psubw (__m64 __m1, __m64 __m2)
>{
> return _mm_sub_pi16 (__m1, __m2);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sub_pi32 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_psubd ((__v2si)__m1, (__v2si)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psubd (__m64 __m1, __m64 __m2)
>{
> return _mm_sub_pi32 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sub_si64 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_psubq ((__v1di)__m1, (__v1di)__m2);
>}
>
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_subs_pi8 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_psubsb ((__v8qi)__m1, (__v8qi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psubsb (__m64 __m1, __m64 __m2)
>{
> return _mm_subs_pi8 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_subs_pi16 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_psubsw ((__v4hi)__m1, (__v4hi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psubsw (__m64 __m1, __m64 __m2)
>{
> return _mm_subs_pi16 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_subs_pu8 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_psubusb ((__v8qi)__m1, (__v8qi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psubusb (__m64 __m1, __m64 __m2)
>{
> return _mm_subs_pu8 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_subs_pu16 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_psubusw ((__v4hi)__m1, (__v4hi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psubusw (__m64 __m1, __m64 __m2)
>{
> return _mm_subs_pu16 (__m1, __m2);
>}
>
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_madd_pi16 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_pmaddwd ((__v4hi)__m1, (__v4hi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pmaddwd (__m64 __m1, __m64 __m2)
>{
> return _mm_madd_pi16 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_mulhi_pi16 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_pmulhw ((__v4hi)__m1, (__v4hi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pmulhw (__m64 __m1, __m64 __m2)
>{
> return _mm_mulhi_pi16 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_mullo_pi16 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_pmullw ((__v4hi)__m1, (__v4hi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pmullw (__m64 __m1, __m64 __m2)
>{
> return _mm_mullo_pi16 (__m1, __m2);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sll_pi16 (__m64 __m, __m64 __count)
>{
> return (__m64) __builtin_ia32_psllw ((__v4hi)__m, (__v4hi)__count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psllw (__m64 __m, __m64 __count)
>{
> return _mm_sll_pi16 (__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_slli_pi16 (__m64 __m, int __count)
>{
> return (__m64) __builtin_ia32_psllwi ((__v4hi)__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psllwi (__m64 __m, int __count)
>{
> return _mm_slli_pi16 (__m, __count);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sll_pi32 (__m64 __m, __m64 __count)
>{
> return (__m64) __builtin_ia32_pslld ((__v2si)__m, (__v2si)__count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pslld (__m64 __m, __m64 __count)
>{
> return _mm_sll_pi32 (__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_slli_pi32 (__m64 __m, int __count)
>{
> return (__m64) __builtin_ia32_pslldi ((__v2si)__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pslldi (__m64 __m, int __count)
>{
> return _mm_slli_pi32 (__m, __count);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sll_si64 (__m64 __m, __m64 __count)
>{
> return (__m64) __builtin_ia32_psllq ((__v1di)__m, (__v1di)__count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psllq (__m64 __m, __m64 __count)
>{
> return _mm_sll_si64 (__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_slli_si64 (__m64 __m, int __count)
>{
> return (__m64) __builtin_ia32_psllqi ((__v1di)__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psllqi (__m64 __m, int __count)
>{
> return _mm_slli_si64 (__m, __count);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sra_pi16 (__m64 __m, __m64 __count)
>{
> return (__m64) __builtin_ia32_psraw ((__v4hi)__m, (__v4hi)__count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psraw (__m64 __m, __m64 __count)
>{
> return _mm_sra_pi16 (__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srai_pi16 (__m64 __m, int __count)
>{
> return (__m64) __builtin_ia32_psrawi ((__v4hi)__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psrawi (__m64 __m, int __count)
>{
> return _mm_srai_pi16 (__m, __count);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sra_pi32 (__m64 __m, __m64 __count)
>{
> return (__m64) __builtin_ia32_psrad ((__v2si)__m, (__v2si)__count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psrad (__m64 __m, __m64 __count)
>{
> return _mm_sra_pi32 (__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srai_pi32 (__m64 __m, int __count)
>{
> return (__m64) __builtin_ia32_psradi ((__v2si)__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psradi (__m64 __m, int __count)
>{
> return _mm_srai_pi32 (__m, __count);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srl_pi16 (__m64 __m, __m64 __count)
>{
> return (__m64) __builtin_ia32_psrlw ((__v4hi)__m, (__v4hi)__count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psrlw (__m64 __m, __m64 __count)
>{
> return _mm_srl_pi16 (__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srli_pi16 (__m64 __m, int __count)
>{
> return (__m64) __builtin_ia32_psrlwi ((__v4hi)__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psrlwi (__m64 __m, int __count)
>{
> return _mm_srli_pi16 (__m, __count);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srl_pi32 (__m64 __m, __m64 __count)
>{
> return (__m64) __builtin_ia32_psrld ((__v2si)__m, (__v2si)__count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psrld (__m64 __m, __m64 __count)
>{
> return _mm_srl_pi32 (__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srli_pi32 (__m64 __m, int __count)
>{
> return (__m64) __builtin_ia32_psrldi ((__v2si)__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psrldi (__m64 __m, int __count)
>{
> return _mm_srli_pi32 (__m, __count);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srl_si64 (__m64 __m, __m64 __count)
>{
> return (__m64) __builtin_ia32_psrlq ((__v1di)__m, (__v1di)__count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psrlq (__m64 __m, __m64 __count)
>{
> return _mm_srl_si64 (__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srli_si64 (__m64 __m, int __count)
>{
> return (__m64) __builtin_ia32_psrlqi ((__v1di)__m, __count);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psrlqi (__m64 __m, int __count)
>{
> return _mm_srli_si64 (__m, __count);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_and_si64 (__m64 __m1, __m64 __m2)
>{
> return __builtin_ia32_pand (__m1, __m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pand (__m64 __m1, __m64 __m2)
>{
> return _mm_and_si64 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_andnot_si64 (__m64 __m1, __m64 __m2)
>{
> return __builtin_ia32_pandn (__m1, __m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pandn (__m64 __m1, __m64 __m2)
>{
> return _mm_andnot_si64 (__m1, __m2);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_or_si64 (__m64 __m1, __m64 __m2)
>{
> return __builtin_ia32_por (__m1, __m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_por (__m64 __m1, __m64 __m2)
>{
> return _mm_or_si64 (__m1, __m2);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_xor_si64 (__m64 __m1, __m64 __m2)
>{
> return __builtin_ia32_pxor (__m1, __m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pxor (__m64 __m1, __m64 __m2)
>{
> return _mm_xor_si64 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpeq_pi8 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_pcmpeqb ((__v8qi)__m1, (__v8qi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pcmpeqb (__m64 __m1, __m64 __m2)
>{
> return _mm_cmpeq_pi8 (__m1, __m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpgt_pi8 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_pcmpgtb ((__v8qi)__m1, (__v8qi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pcmpgtb (__m64 __m1, __m64 __m2)
>{
> return _mm_cmpgt_pi8 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpeq_pi16 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_pcmpeqw ((__v4hi)__m1, (__v4hi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pcmpeqw (__m64 __m1, __m64 __m2)
>{
> return _mm_cmpeq_pi16 (__m1, __m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpgt_pi16 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_pcmpgtw ((__v4hi)__m1, (__v4hi)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pcmpgtw (__m64 __m1, __m64 __m2)
>{
> return _mm_cmpgt_pi16 (__m1, __m2);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpeq_pi32 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_pcmpeqd ((__v2si)__m1, (__v2si)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pcmpeqd (__m64 __m1, __m64 __m2)
>{
> return _mm_cmpeq_pi32 (__m1, __m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpgt_pi32 (__m64 __m1, __m64 __m2)
>{
> return (__m64) __builtin_ia32_pcmpgtd ((__v2si)__m1, (__v2si)__m2);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pcmpgtd (__m64 __m1, __m64 __m2)
>{
> return _mm_cmpgt_pi32 (__m1, __m2);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_setzero_si64 (void)
>{
> return (__m64)0LL;
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set_pi32 (int __i1, int __i0)
>{
> return (__m64) __builtin_ia32_vec_init_v2si (__i0, __i1);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set_pi16 (short __w3, short __w2, short __w1, short __w0)
>{
> return (__m64) __builtin_ia32_vec_init_v4hi (__w0, __w1, __w2, __w3);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set_pi8 (char __b7, char __b6, char __b5, char __b4,
> char __b3, char __b2, char __b1, char __b0)
>{
> return (__m64) __builtin_ia32_vec_init_v8qi (__b0, __b1, __b2, __b3,
> __b4, __b5, __b6, __b7);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_setr_pi32 (int __i0, int __i1)
>{
> return _mm_set_pi32 (__i1, __i0);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_setr_pi16 (short __w0, short __w1, short __w2, short __w3)
>{
> return _mm_set_pi16 (__w3, __w2, __w1, __w0);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_setr_pi8 (char __b0, char __b1, char __b2, char __b3,
> char __b4, char __b5, char __b6, char __b7)
>{
> return _mm_set_pi8 (__b7, __b6, __b5, __b4, __b3, __b2, __b1, __b0);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set1_pi32 (int __i)
>{
> return _mm_set_pi32 (__i, __i);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set1_pi16 (short __w)
>{
> return _mm_set_pi16 (__w, __w, __w, __w);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set1_pi8 (char __b)
>{
> return _mm_set_pi8 (__b, __b, __b, __b, __b, __b, __b, __b);
>}
># 31 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/x86intrin.h" 2 3 4
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/xmmintrin.h" 1 3 4
># 38 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/xmmintrin.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/mm_malloc.h" 1 3 4
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/mm_malloc.h" 3 4
>extern "C" int posix_memalign (void **, size_t, size_t) throw ();
>
>
>static __inline void *
>_mm_malloc (size_t size, size_t alignment)
>{
> void *ptr;
> if (alignment == 1)
> return malloc (size);
> if (alignment == 2 || (sizeof (void *) == 8 && alignment == 4))
> alignment = sizeof (void *);
> if (posix_memalign (&ptr, alignment, size) == 0)
> return ptr;
> else
> return __null;
>}
>
>static __inline void
>_mm_free (void * ptr)
>{
> free (ptr);
>}
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/xmmintrin.h" 2 3 4
>
>
>
>typedef float __m128 __attribute__ ((__vector_size__ (16), __may_alias__));
>
>
>typedef float __v4sf __attribute__ ((__vector_size__ (16)));
>
>
>
>
>
>
>enum _mm_hint
>{
> _MM_HINT_T0 = 3,
> _MM_HINT_T1 = 2,
> _MM_HINT_T2 = 1,
> _MM_HINT_NTA = 0
>};
># 88 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/xmmintrin.h" 3 4
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_setzero_ps (void)
>{
> return __extension__ (__m128){ 0.0f, 0.0f, 0.0f, 0.0f };
>}
>
>
>
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_add_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_addss ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sub_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_subss ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_mul_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_mulss ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_div_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_divss ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sqrt_ss (__m128 __A)
>{
> return (__m128) __builtin_ia32_sqrtss ((__v4sf)__A);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_rcp_ss (__m128 __A)
>{
> return (__m128) __builtin_ia32_rcpss ((__v4sf)__A);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_rsqrt_ss (__m128 __A)
>{
> return (__m128) __builtin_ia32_rsqrtss ((__v4sf)__A);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_min_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_minss ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_max_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_maxss ((__v4sf)__A, (__v4sf)__B);
>}
>
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_add_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_addps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sub_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_subps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_mul_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_mulps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_div_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_divps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sqrt_ps (__m128 __A)
>{
> return (__m128) __builtin_ia32_sqrtps ((__v4sf)__A);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_rcp_ps (__m128 __A)
>{
> return (__m128) __builtin_ia32_rcpps ((__v4sf)__A);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_rsqrt_ps (__m128 __A)
>{
> return (__m128) __builtin_ia32_rsqrtps ((__v4sf)__A);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_min_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_minps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_max_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_maxps ((__v4sf)__A, (__v4sf)__B);
>}
>
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_and_ps (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_andps (__A, __B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_andnot_ps (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_andnps (__A, __B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_or_ps (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_orps (__A, __B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_xor_ps (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_xorps (__A, __B);
>}
>
>
>
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpeq_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpeqss ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmplt_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpltss ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmple_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpless ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpgt_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_movss ((__v4sf) __A,
> (__v4sf)
> __builtin_ia32_cmpltss ((__v4sf) __B,
> (__v4sf)
> __A));
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpge_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_movss ((__v4sf) __A,
> (__v4sf)
> __builtin_ia32_cmpless ((__v4sf) __B,
> (__v4sf)
> __A));
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpneq_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpneqss ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpnlt_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpnltss ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpnle_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpnless ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpngt_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_movss ((__v4sf) __A,
> (__v4sf)
> __builtin_ia32_cmpnltss ((__v4sf) __B,
> (__v4sf)
> __A));
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpnge_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_movss ((__v4sf) __A,
> (__v4sf)
> __builtin_ia32_cmpnless ((__v4sf) __B,
> (__v4sf)
> __A));
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpord_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpordss ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpunord_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpunordss ((__v4sf)__A, (__v4sf)__B);
>}
>
>
>
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpeq_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpeqps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmplt_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpltps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmple_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpleps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpgt_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpgtps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpge_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpgeps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpneq_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpneqps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpnlt_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpnltps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpnle_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpnleps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpngt_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpngtps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpnge_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpngeps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpord_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpordps ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpunord_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_cmpunordps ((__v4sf)__A, (__v4sf)__B);
>}
>
>
>
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_comieq_ss (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_comieq ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_comilt_ss (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_comilt ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_comile_ss (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_comile ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_comigt_ss (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_comigt ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_comige_ss (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_comige ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_comineq_ss (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_comineq ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_ucomieq_ss (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_ucomieq ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_ucomilt_ss (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_ucomilt ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_ucomile_ss (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_ucomile ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_ucomigt_ss (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_ucomigt ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_ucomige_ss (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_ucomige ((__v4sf)__A, (__v4sf)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_ucomineq_ss (__m128 __A, __m128 __B)
>{
> return __builtin_ia32_ucomineq ((__v4sf)__A, (__v4sf)__B);
>}
>
>
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtss_si32 (__m128 __A)
>{
> return __builtin_ia32_cvtss2si ((__v4sf) __A);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvt_ss2si (__m128 __A)
>{
> return _mm_cvtss_si32 (__A);
>}
>
>
>
>
>
>
>extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtss_si64 (__m128 __A)
>{
> return __builtin_ia32_cvtss2si64 ((__v4sf) __A);
>}
>
>
>extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtss_si64x (__m128 __A)
>{
> return __builtin_ia32_cvtss2si64 ((__v4sf) __A);
>}
>
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtps_pi32 (__m128 __A)
>{
> return (__m64) __builtin_ia32_cvtps2pi ((__v4sf) __A);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvt_ps2pi (__m128 __A)
>{
> return _mm_cvtps_pi32 (__A);
>}
>
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvttss_si32 (__m128 __A)
>{
> return __builtin_ia32_cvttss2si ((__v4sf) __A);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtt_ss2si (__m128 __A)
>{
> return _mm_cvttss_si32 (__A);
>}
>
>
>
>
>
>extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvttss_si64 (__m128 __A)
>{
> return __builtin_ia32_cvttss2si64 ((__v4sf) __A);
>}
>
>
>extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvttss_si64x (__m128 __A)
>{
> return __builtin_ia32_cvttss2si64 ((__v4sf) __A);
>}
>
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvttps_pi32 (__m128 __A)
>{
> return (__m64) __builtin_ia32_cvttps2pi ((__v4sf) __A);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtt_ps2pi (__m128 __A)
>{
> return _mm_cvttps_pi32 (__A);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi32_ss (__m128 __A, int __B)
>{
> return (__m128) __builtin_ia32_cvtsi2ss ((__v4sf) __A, __B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvt_si2ss (__m128 __A, int __B)
>{
> return _mm_cvtsi32_ss (__A, __B);
>}
>
>
>
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi64_ss (__m128 __A, long long __B)
>{
> return (__m128) __builtin_ia32_cvtsi642ss ((__v4sf) __A, __B);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi64x_ss (__m128 __A, long long __B)
>{
> return (__m128) __builtin_ia32_cvtsi642ss ((__v4sf) __A, __B);
>}
>
>
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtpi32_ps (__m128 __A, __m64 __B)
>{
> return (__m128) __builtin_ia32_cvtpi2ps ((__v4sf) __A, (__v2si)__B);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvt_pi2ps (__m128 __A, __m64 __B)
>{
> return _mm_cvtpi32_ps (__A, __B);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtpi16_ps (__m64 __A)
>{
> __v4hi __sign;
> __v2si __hisi, __losi;
> __v4sf __zero, __ra, __rb;
>
>
>
>
> __sign = __builtin_ia32_pcmpgtw ((__v4hi)0LL, (__v4hi)__A);
>
>
> __losi = (__v2si) __builtin_ia32_punpcklwd ((__v4hi)__A, __sign);
> __hisi = (__v2si) __builtin_ia32_punpckhwd ((__v4hi)__A, __sign);
>
>
> __zero = (__v4sf) _mm_setzero_ps ();
> __ra = __builtin_ia32_cvtpi2ps (__zero, __losi);
> __rb = __builtin_ia32_cvtpi2ps (__ra, __hisi);
>
> return (__m128) __builtin_ia32_movlhps (__ra, __rb);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtpu16_ps (__m64 __A)
>{
> __v2si __hisi, __losi;
> __v4sf __zero, __ra, __rb;
>
>
> __losi = (__v2si) __builtin_ia32_punpcklwd ((__v4hi)__A, (__v4hi)0LL);
> __hisi = (__v2si) __builtin_ia32_punpckhwd ((__v4hi)__A, (__v4hi)0LL);
>
>
> __zero = (__v4sf) _mm_setzero_ps ();
> __ra = __builtin_ia32_cvtpi2ps (__zero, __losi);
> __rb = __builtin_ia32_cvtpi2ps (__ra, __hisi);
>
> return (__m128) __builtin_ia32_movlhps (__ra, __rb);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtpi8_ps (__m64 __A)
>{
> __v8qi __sign;
>
>
>
>
> __sign = __builtin_ia32_pcmpgtb ((__v8qi)0LL, (__v8qi)__A);
>
>
> __A = (__m64) __builtin_ia32_punpcklbw ((__v8qi)__A, __sign);
>
> return _mm_cvtpi16_ps(__A);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtpu8_ps(__m64 __A)
>{
> __A = (__m64) __builtin_ia32_punpcklbw ((__v8qi)__A, (__v8qi)0LL);
> return _mm_cvtpu16_ps(__A);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtpi32x2_ps(__m64 __A, __m64 __B)
>{
> __v4sf __zero = (__v4sf) _mm_setzero_ps ();
> __v4sf __sfa = __builtin_ia32_cvtpi2ps (__zero, (__v2si)__A);
> __v4sf __sfb = __builtin_ia32_cvtpi2ps (__sfa, (__v2si)__B);
> return (__m128) __builtin_ia32_movlhps (__sfa, __sfb);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtps_pi16(__m128 __A)
>{
> __v4sf __hisf = (__v4sf)__A;
> __v4sf __losf = __builtin_ia32_movhlps (__hisf, __hisf);
> __v2si __hisi = __builtin_ia32_cvtps2pi (__hisf);
> __v2si __losi = __builtin_ia32_cvtps2pi (__losf);
> return (__m64) __builtin_ia32_packssdw (__hisi, __losi);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtps_pi8(__m128 __A)
>{
> __v4hi __tmp = (__v4hi) _mm_cvtps_pi16 (__A);
> return (__m64) __builtin_ia32_packsswb (__tmp, (__v4hi)0LL);
>}
>
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_shuffle_ps (__m128 __A, __m128 __B, int const __mask)
>{
> return (__m128) __builtin_ia32_shufps ((__v4sf)__A, (__v4sf)__B, __mask);
>}
>
>
>
>
>
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpackhi_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_unpckhps ((__v4sf)__A, (__v4sf)__B);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpacklo_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_unpcklps ((__v4sf)__A, (__v4sf)__B);
>}
>
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_loadh_pi (__m128 __A, __m64 const *__P)
>{
> return (__m128) __builtin_ia32_loadhps ((__v4sf)__A, (const __v2sf *)__P);
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_storeh_pi (__m64 *__P, __m128 __A)
>{
> __builtin_ia32_storehps ((__v2sf *)__P, (__v4sf)__A);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_movehl_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_movhlps ((__v4sf)__A, (__v4sf)__B);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_movelh_ps (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_movlhps ((__v4sf)__A, (__v4sf)__B);
>}
>
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_loadl_pi (__m128 __A, __m64 const *__P)
>{
> return (__m128) __builtin_ia32_loadlps ((__v4sf)__A, (const __v2sf *)__P);
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_storel_pi (__m64 *__P, __m128 __A)
>{
> __builtin_ia32_storelps ((__v2sf *)__P, (__v4sf)__A);
>}
>
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_movemask_ps (__m128 __A)
>{
> return __builtin_ia32_movmskps ((__v4sf)__A);
>}
>
>
>extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_getcsr (void)
>{
> return __builtin_ia32_stmxcsr ();
>}
>
>
>extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_MM_GET_EXCEPTION_STATE (void)
>{
> return _mm_getcsr() & 0x003f;
>}
>
>extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_MM_GET_EXCEPTION_MASK (void)
>{
> return _mm_getcsr() & 0x1f80;
>}
>
>extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_MM_GET_ROUNDING_MODE (void)
>{
> return _mm_getcsr() & 0x6000;
>}
>
>extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_MM_GET_FLUSH_ZERO_MODE (void)
>{
> return _mm_getcsr() & 0x8000;
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_setcsr (unsigned int __I)
>{
> __builtin_ia32_ldmxcsr (__I);
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_MM_SET_EXCEPTION_STATE(unsigned int __mask)
>{
> _mm_setcsr((_mm_getcsr() & ~0x003f) | __mask);
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_MM_SET_EXCEPTION_MASK (unsigned int __mask)
>{
> _mm_setcsr((_mm_getcsr() & ~0x1f80) | __mask);
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_MM_SET_ROUNDING_MODE (unsigned int __mode)
>{
> _mm_setcsr((_mm_getcsr() & ~0x6000) | __mode);
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_MM_SET_FLUSH_ZERO_MODE (unsigned int __mode)
>{
> _mm_setcsr((_mm_getcsr() & ~0x8000) | __mode);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set_ss (float __F)
>{
> return __extension__ (__m128)(__v4sf){ __F, 0.0f, 0.0f, 0.0f };
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set1_ps (float __F)
>{
> return __extension__ (__m128)(__v4sf){ __F, __F, __F, __F };
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set_ps1 (float __F)
>{
> return _mm_set1_ps (__F);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_load_ss (float const *__P)
>{
> return _mm_set_ss (*__P);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_load1_ps (float const *__P)
>{
> return _mm_set1_ps (*__P);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_load_ps1 (float const *__P)
>{
> return _mm_load1_ps (__P);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_load_ps (float const *__P)
>{
> return (__m128) *(__v4sf *)__P;
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_loadu_ps (float const *__P)
>{
> return (__m128) __builtin_ia32_loadups (__P);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_loadr_ps (float const *__P)
>{
> __v4sf __tmp = *(__v4sf *)__P;
> return (__m128) __builtin_ia32_shufps (__tmp, __tmp, (((0) << 6) | ((1) << 4) | ((2) << 2) | (3)));
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set_ps (const float __Z, const float __Y, const float __X, const float __W)
>{
> return __extension__ (__m128)(__v4sf){ __W, __X, __Y, __Z };
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_setr_ps (float __Z, float __Y, float __X, float __W)
>{
> return __extension__ (__m128)(__v4sf){ __Z, __Y, __X, __W };
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_store_ss (float *__P, __m128 __A)
>{
> *__P = __builtin_ia32_vec_ext_v4sf ((__v4sf)__A, 0);
>}
>
>extern __inline float __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtss_f32 (__m128 __A)
>{
> return __builtin_ia32_vec_ext_v4sf ((__v4sf)__A, 0);
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_store_ps (float *__P, __m128 __A)
>{
> *(__v4sf *)__P = (__v4sf)__A;
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_storeu_ps (float *__P, __m128 __A)
>{
> __builtin_ia32_storeups (__P, (__v4sf)__A);
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_store1_ps (float *__P, __m128 __A)
>{
> __v4sf __va = (__v4sf)__A;
> __v4sf __tmp = __builtin_ia32_shufps (__va, __va, (((0) << 6) | ((0) << 4) | ((0) << 2) | (0)));
> _mm_storeu_ps (__P, __tmp);
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_store_ps1 (float *__P, __m128 __A)
>{
> _mm_store1_ps (__P, __A);
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_storer_ps (float *__P, __m128 __A)
>{
> __v4sf __va = (__v4sf)__A;
> __v4sf __tmp = __builtin_ia32_shufps (__va, __va, (((0) << 6) | ((1) << 4) | ((2) << 2) | (3)));
> _mm_store_ps (__P, __tmp);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_move_ss (__m128 __A, __m128 __B)
>{
> return (__m128) __builtin_ia32_movss ((__v4sf)__A, (__v4sf)__B);
>}
>
>
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_extract_pi16 (__m64 const __A, int const __N)
>{
> return __builtin_ia32_vec_ext_v4hi ((__v4hi)__A, __N);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pextrw (__m64 const __A, int const __N)
>{
> return _mm_extract_pi16 (__A, __N);
>}
># 1011 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/xmmintrin.h" 3 4
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_insert_pi16 (__m64 const __A, int const __D, int const __N)
>{
> return (__m64) __builtin_ia32_vec_set_v4hi ((__v4hi)__A, __D, __N);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pinsrw (__m64 const __A, int const __D, int const __N)
>{
> return _mm_insert_pi16 (__A, __D, __N);
>}
># 1031 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/xmmintrin.h" 3 4
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_max_pi16 (__m64 __A, __m64 __B)
>{
> return (__m64) __builtin_ia32_pmaxsw ((__v4hi)__A, (__v4hi)__B);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pmaxsw (__m64 __A, __m64 __B)
>{
> return _mm_max_pi16 (__A, __B);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_max_pu8 (__m64 __A, __m64 __B)
>{
> return (__m64) __builtin_ia32_pmaxub ((__v8qi)__A, (__v8qi)__B);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pmaxub (__m64 __A, __m64 __B)
>{
> return _mm_max_pu8 (__A, __B);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_min_pi16 (__m64 __A, __m64 __B)
>{
> return (__m64) __builtin_ia32_pminsw ((__v4hi)__A, (__v4hi)__B);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pminsw (__m64 __A, __m64 __B)
>{
> return _mm_min_pi16 (__A, __B);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_min_pu8 (__m64 __A, __m64 __B)
>{
> return (__m64) __builtin_ia32_pminub ((__v8qi)__A, (__v8qi)__B);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pminub (__m64 __A, __m64 __B)
>{
> return _mm_min_pu8 (__A, __B);
>}
>
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_movemask_pi8 (__m64 __A)
>{
> return __builtin_ia32_pmovmskb ((__v8qi)__A);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pmovmskb (__m64 __A)
>{
> return _mm_movemask_pi8 (__A);
>}
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_mulhi_pu16 (__m64 __A, __m64 __B)
>{
> return (__m64) __builtin_ia32_pmulhuw ((__v4hi)__A, (__v4hi)__B);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pmulhuw (__m64 __A, __m64 __B)
>{
> return _mm_mulhi_pu16 (__A, __B);
>}
>
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_shuffle_pi16 (__m64 __A, int const __N)
>{
> return (__m64) __builtin_ia32_pshufw ((__v4hi)__A, __N);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pshufw (__m64 __A, int const __N)
>{
> return _mm_shuffle_pi16 (__A, __N);
>}
># 1133 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/xmmintrin.h" 3 4
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_maskmove_si64 (__m64 __A, __m64 __N, char *__P)
>{
> __builtin_ia32_maskmovq ((__v8qi)__A, (__v8qi)__N, __P);
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_maskmovq (__m64 __A, __m64 __N, char *__P)
>{
> _mm_maskmove_si64 (__A, __N, __P);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_avg_pu8 (__m64 __A, __m64 __B)
>{
> return (__m64) __builtin_ia32_pavgb ((__v8qi)__A, (__v8qi)__B);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pavgb (__m64 __A, __m64 __B)
>{
> return _mm_avg_pu8 (__A, __B);
>}
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_avg_pu16 (__m64 __A, __m64 __B)
>{
> return (__m64) __builtin_ia32_pavgw ((__v4hi)__A, (__v4hi)__B);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_pavgw (__m64 __A, __m64 __B)
>{
> return _mm_avg_pu16 (__A, __B);
>}
>
>
>
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sad_pu8 (__m64 __A, __m64 __B)
>{
> return (__m64) __builtin_ia32_psadbw ((__v8qi)__A, (__v8qi)__B);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_m_psadbw (__m64 __A, __m64 __B)
>{
> return _mm_sad_pu8 (__A, __B);
>}
>
>
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_prefetch (const void *__P, enum _mm_hint __I)
>{
> __builtin_prefetch (__P, 0, __I);
>}
>
>
>
>
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_stream_pi (__m64 *__P, __m64 __A)
>{
> __builtin_ia32_movntq ((unsigned long long *)__P, (unsigned long long)__A);
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_stream_ps (float *__P, __m128 __A)
>{
> __builtin_ia32_movntps (__P, (__v4sf)__A);
>}
>
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sfence (void)
>{
> __builtin_ia32_sfence ();
>}
>
>
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_pause (void)
>{
> __builtin_ia32_pause ();
>}
># 1246 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/xmmintrin.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/emmintrin.h" 1 3 4
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/emmintrin.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/xmmintrin.h" 1 3 4
># 36 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/emmintrin.h" 2 3 4
>
>
>typedef double __v2df __attribute__ ((__vector_size__ (16)));
>typedef long long __v2di __attribute__ ((__vector_size__ (16)));
>typedef int __v4si __attribute__ ((__vector_size__ (16)));
>typedef short __v8hi __attribute__ ((__vector_size__ (16)));
>typedef char __v16qi __attribute__ ((__vector_size__ (16)));
>
>
>
>typedef long long __m128i __attribute__ ((__vector_size__ (16), __may_alias__));
>typedef double __m128d __attribute__ ((__vector_size__ (16), __may_alias__));
>
>
>
>
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set_sd (double __F)
>{
> return __extension__ (__m128d){ __F, 0.0 };
>}
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set1_pd (double __F)
>{
> return __extension__ (__m128d){ __F, __F };
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set_pd1 (double __F)
>{
> return _mm_set1_pd (__F);
>}
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set_pd (double __W, double __X)
>{
> return __extension__ (__m128d){ __X, __W };
>}
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_setr_pd (double __W, double __X)
>{
> return __extension__ (__m128d){ __W, __X };
>}
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_setzero_pd (void)
>{
> return __extension__ (__m128d){ 0.0, 0.0 };
>}
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_move_sd (__m128d __A, __m128d __B)
>{
> return (__m128d) __builtin_ia32_movsd ((__v2df)__A, (__v2df)__B);
>}
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_load_pd (double const *__P)
>{
> return *(__m128d *)__P;
>}
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_loadu_pd (double const *__P)
>{
> return __builtin_ia32_loadupd (__P);
>}
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_load1_pd (double const *__P)
>{
> return _mm_set1_pd (*__P);
>}
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_load_sd (double const *__P)
>{
> return _mm_set_sd (*__P);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_load_pd1 (double const *__P)
>{
> return _mm_load1_pd (__P);
>}
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_loadr_pd (double const *__P)
>{
> __m128d __tmp = _mm_load_pd (__P);
> return __builtin_ia32_shufpd (__tmp, __tmp, (((0) << 1) | (1)));
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_store_pd (double *__P, __m128d __A)
>{
> *(__m128d *)__P = __A;
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_storeu_pd (double *__P, __m128d __A)
>{
> __builtin_ia32_storeupd (__P, __A);
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_store_sd (double *__P, __m128d __A)
>{
> *__P = __builtin_ia32_vec_ext_v2df (__A, 0);
>}
>
>extern __inline double __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsd_f64 (__m128d __A)
>{
> return __builtin_ia32_vec_ext_v2df (__A, 0);
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_storel_pd (double *__P, __m128d __A)
>{
> _mm_store_sd (__P, __A);
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_storeh_pd (double *__P, __m128d __A)
>{
> *__P = __builtin_ia32_vec_ext_v2df (__A, 1);
>}
>
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_store1_pd (double *__P, __m128d __A)
>{
> _mm_store_pd (__P, __builtin_ia32_shufpd (__A, __A, (((0) << 1) | (0))));
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_store_pd1 (double *__P, __m128d __A)
>{
> _mm_store1_pd (__P, __A);
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_storer_pd (double *__P, __m128d __A)
>{
> _mm_store_pd (__P, __builtin_ia32_shufpd (__A, __A, (((0) << 1) | (1))));
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi128_si32 (__m128i __A)
>{
> return __builtin_ia32_vec_ext_v4si ((__v4si)__A, 0);
>}
>
>
>
>extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi128_si64 (__m128i __A)
>{
> return __builtin_ia32_vec_ext_v2di ((__v2di)__A, 0);
>}
>
>
>extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi128_si64x (__m128i __A)
>{
> return __builtin_ia32_vec_ext_v2di ((__v2di)__A, 0);
>}
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_add_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_addpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_add_sd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_addsd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sub_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_subpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sub_sd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_subsd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_mul_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_mulpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_mul_sd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_mulsd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_div_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_divpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_div_sd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_divsd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sqrt_pd (__m128d __A)
>{
> return (__m128d)__builtin_ia32_sqrtpd ((__v2df)__A);
>}
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sqrt_sd (__m128d __A, __m128d __B)
>{
> __v2df __tmp = __builtin_ia32_movsd ((__v2df)__A, (__v2df)__B);
> return (__m128d)__builtin_ia32_sqrtsd ((__v2df)__tmp);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_min_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_minpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_min_sd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_minsd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_max_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_maxpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_max_sd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_maxsd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_and_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_andpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_andnot_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_andnpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_or_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_orpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_xor_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_xorpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpeq_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpeqpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmplt_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpltpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmple_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmplepd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpgt_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpgtpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpge_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpgepd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpneq_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpneqpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpnlt_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpnltpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpnle_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpnlepd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpngt_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpngtpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpnge_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpngepd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpord_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpordpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpunord_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpunordpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpeq_sd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpeqsd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmplt_sd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpltsd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmple_sd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmplesd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpgt_sd (__m128d __A, __m128d __B)
>{
> return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
> (__v2df)
> __builtin_ia32_cmpltsd ((__v2df) __B,
> (__v2df)
> __A));
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpge_sd (__m128d __A, __m128d __B)
>{
> return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
> (__v2df)
> __builtin_ia32_cmplesd ((__v2df) __B,
> (__v2df)
> __A));
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpneq_sd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpneqsd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpnlt_sd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpnltsd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpnle_sd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpnlesd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpngt_sd (__m128d __A, __m128d __B)
>{
> return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
> (__v2df)
> __builtin_ia32_cmpnltsd ((__v2df) __B,
> (__v2df)
> __A));
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpnge_sd (__m128d __A, __m128d __B)
>{
> return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
> (__v2df)
> __builtin_ia32_cmpnlesd ((__v2df) __B,
> (__v2df)
> __A));
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpord_sd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpordsd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpunord_sd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_cmpunordsd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_comieq_sd (__m128d __A, __m128d __B)
>{
> return __builtin_ia32_comisdeq ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_comilt_sd (__m128d __A, __m128d __B)
>{
> return __builtin_ia32_comisdlt ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_comile_sd (__m128d __A, __m128d __B)
>{
> return __builtin_ia32_comisdle ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_comigt_sd (__m128d __A, __m128d __B)
>{
> return __builtin_ia32_comisdgt ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_comige_sd (__m128d __A, __m128d __B)
>{
> return __builtin_ia32_comisdge ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_comineq_sd (__m128d __A, __m128d __B)
>{
> return __builtin_ia32_comisdneq ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_ucomieq_sd (__m128d __A, __m128d __B)
>{
> return __builtin_ia32_ucomisdeq ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_ucomilt_sd (__m128d __A, __m128d __B)
>{
> return __builtin_ia32_ucomisdlt ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_ucomile_sd (__m128d __A, __m128d __B)
>{
> return __builtin_ia32_ucomisdle ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_ucomigt_sd (__m128d __A, __m128d __B)
>{
> return __builtin_ia32_ucomisdgt ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_ucomige_sd (__m128d __A, __m128d __B)
>{
> return __builtin_ia32_ucomisdge ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_ucomineq_sd (__m128d __A, __m128d __B)
>{
> return __builtin_ia32_ucomisdneq ((__v2df)__A, (__v2df)__B);
>}
>
>
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set_epi64x (long long __q1, long long __q0)
>{
> return __extension__ (__m128i)(__v2di){ __q0, __q1 };
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set_epi64 (__m64 __q1, __m64 __q0)
>{
> return _mm_set_epi64x ((long long)__q1, (long long)__q0);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set_epi32 (int __q3, int __q2, int __q1, int __q0)
>{
> return __extension__ (__m128i)(__v4si){ __q0, __q1, __q2, __q3 };
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set_epi16 (short __q7, short __q6, short __q5, short __q4,
> short __q3, short __q2, short __q1, short __q0)
>{
> return __extension__ (__m128i)(__v8hi){
> __q0, __q1, __q2, __q3, __q4, __q5, __q6, __q7 };
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set_epi8 (char __q15, char __q14, char __q13, char __q12,
> char __q11, char __q10, char __q09, char __q08,
> char __q07, char __q06, char __q05, char __q04,
> char __q03, char __q02, char __q01, char __q00)
>{
> return __extension__ (__m128i)(__v16qi){
> __q00, __q01, __q02, __q03, __q04, __q05, __q06, __q07,
> __q08, __q09, __q10, __q11, __q12, __q13, __q14, __q15
> };
>}
>
>
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set1_epi64x (long long __A)
>{
> return _mm_set_epi64x (__A, __A);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set1_epi64 (__m64 __A)
>{
> return _mm_set_epi64 (__A, __A);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set1_epi32 (int __A)
>{
> return _mm_set_epi32 (__A, __A, __A, __A);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set1_epi16 (short __A)
>{
> return _mm_set_epi16 (__A, __A, __A, __A, __A, __A, __A, __A);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_set1_epi8 (char __A)
>{
> return _mm_set_epi8 (__A, __A, __A, __A, __A, __A, __A, __A,
> __A, __A, __A, __A, __A, __A, __A, __A);
>}
>
>
>
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_setr_epi64 (__m64 __q0, __m64 __q1)
>{
> return _mm_set_epi64 (__q1, __q0);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_setr_epi32 (int __q0, int __q1, int __q2, int __q3)
>{
> return _mm_set_epi32 (__q3, __q2, __q1, __q0);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_setr_epi16 (short __q0, short __q1, short __q2, short __q3,
> short __q4, short __q5, short __q6, short __q7)
>{
> return _mm_set_epi16 (__q7, __q6, __q5, __q4, __q3, __q2, __q1, __q0);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_setr_epi8 (char __q00, char __q01, char __q02, char __q03,
> char __q04, char __q05, char __q06, char __q07,
> char __q08, char __q09, char __q10, char __q11,
> char __q12, char __q13, char __q14, char __q15)
>{
> return _mm_set_epi8 (__q15, __q14, __q13, __q12, __q11, __q10, __q09, __q08,
> __q07, __q06, __q05, __q04, __q03, __q02, __q01, __q00);
>}
>
>
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_load_si128 (__m128i const *__P)
>{
> return *__P;
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_loadu_si128 (__m128i const *__P)
>{
> return (__m128i) __builtin_ia32_loaddqu ((char const *)__P);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_loadl_epi64 (__m128i const *__P)
>{
> return _mm_set_epi64 ((__m64)0LL, *(__m64 *)__P);
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_store_si128 (__m128i *__P, __m128i __B)
>{
> *__P = __B;
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_storeu_si128 (__m128i *__P, __m128i __B)
>{
> __builtin_ia32_storedqu ((char *)__P, (__v16qi)__B);
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_storel_epi64 (__m128i *__P, __m128i __B)
>{
> *(long long *)__P = __builtin_ia32_vec_ext_v2di ((__v2di)__B, 0);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_movepi64_pi64 (__m128i __B)
>{
> return (__m64) __builtin_ia32_vec_ext_v2di ((__v2di)__B, 0);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_movpi64_epi64 (__m64 __A)
>{
> return _mm_set_epi64 ((__m64)0LL, __A);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_move_epi64 (__m128i __A)
>{
> return (__m128i)__builtin_ia32_movq128 ((__v2di) __A);
>}
>
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_setzero_si128 (void)
>{
> return __extension__ (__m128i)(__v4si){ 0, 0, 0, 0 };
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtepi32_pd (__m128i __A)
>{
> return (__m128d)__builtin_ia32_cvtdq2pd ((__v4si) __A);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtepi32_ps (__m128i __A)
>{
> return (__m128)__builtin_ia32_cvtdq2ps ((__v4si) __A);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtpd_epi32 (__m128d __A)
>{
> return (__m128i)__builtin_ia32_cvtpd2dq ((__v2df) __A);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtpd_pi32 (__m128d __A)
>{
> return (__m64)__builtin_ia32_cvtpd2pi ((__v2df) __A);
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtpd_ps (__m128d __A)
>{
> return (__m128)__builtin_ia32_cvtpd2ps ((__v2df) __A);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvttpd_epi32 (__m128d __A)
>{
> return (__m128i)__builtin_ia32_cvttpd2dq ((__v2df) __A);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvttpd_pi32 (__m128d __A)
>{
> return (__m64)__builtin_ia32_cvttpd2pi ((__v2df) __A);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtpi32_pd (__m64 __A)
>{
> return (__m128d)__builtin_ia32_cvtpi2pd ((__v2si) __A);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtps_epi32 (__m128 __A)
>{
> return (__m128i)__builtin_ia32_cvtps2dq ((__v4sf) __A);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvttps_epi32 (__m128 __A)
>{
> return (__m128i)__builtin_ia32_cvttps2dq ((__v4sf) __A);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtps_pd (__m128 __A)
>{
> return (__m128d)__builtin_ia32_cvtps2pd ((__v4sf) __A);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsd_si32 (__m128d __A)
>{
> return __builtin_ia32_cvtsd2si ((__v2df) __A);
>}
>
>
>
>extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsd_si64 (__m128d __A)
>{
> return __builtin_ia32_cvtsd2si64 ((__v2df) __A);
>}
>
>
>extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsd_si64x (__m128d __A)
>{
> return __builtin_ia32_cvtsd2si64 ((__v2df) __A);
>}
>
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvttsd_si32 (__m128d __A)
>{
> return __builtin_ia32_cvttsd2si ((__v2df) __A);
>}
>
>
>
>extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvttsd_si64 (__m128d __A)
>{
> return __builtin_ia32_cvttsd2si64 ((__v2df) __A);
>}
>
>
>extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvttsd_si64x (__m128d __A)
>{
> return __builtin_ia32_cvttsd2si64 ((__v2df) __A);
>}
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsd_ss (__m128 __A, __m128d __B)
>{
> return (__m128)__builtin_ia32_cvtsd2ss ((__v4sf) __A, (__v2df) __B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi32_sd (__m128d __A, int __B)
>{
> return (__m128d)__builtin_ia32_cvtsi2sd ((__v2df) __A, __B);
>}
>
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi64_sd (__m128d __A, long long __B)
>{
> return (__m128d)__builtin_ia32_cvtsi642sd ((__v2df) __A, __B);
>}
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi64x_sd (__m128d __A, long long __B)
>{
> return (__m128d)__builtin_ia32_cvtsi642sd ((__v2df) __A, __B);
>}
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtss_sd (__m128d __A, __m128 __B)
>{
> return (__m128d)__builtin_ia32_cvtss2sd ((__v2df) __A, (__v4sf)__B);
>}
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_shuffle_pd(__m128d __A, __m128d __B, const int __mask)
>{
> return (__m128d)__builtin_ia32_shufpd ((__v2df)__A, (__v2df)__B, __mask);
>}
>
>
>
>
>
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpackhi_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_unpckhpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpacklo_pd (__m128d __A, __m128d __B)
>{
> return (__m128d)__builtin_ia32_unpcklpd ((__v2df)__A, (__v2df)__B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_loadh_pd (__m128d __A, double const *__B)
>{
> return (__m128d)__builtin_ia32_loadhpd ((__v2df)__A, __B);
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_loadl_pd (__m128d __A, double const *__B)
>{
> return (__m128d)__builtin_ia32_loadlpd ((__v2df)__A, __B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_movemask_pd (__m128d __A)
>{
> return __builtin_ia32_movmskpd ((__v2df)__A);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_packs_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_packsswb128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_packs_epi32 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_packssdw128 ((__v4si)__A, (__v4si)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_packus_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_packuswb128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpackhi_epi8 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_punpckhbw128 ((__v16qi)__A, (__v16qi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpackhi_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_punpckhwd128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpackhi_epi32 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_punpckhdq128 ((__v4si)__A, (__v4si)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpackhi_epi64 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_punpckhqdq128 ((__v2di)__A, (__v2di)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpacklo_epi8 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_punpcklbw128 ((__v16qi)__A, (__v16qi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpacklo_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_punpcklwd128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpacklo_epi32 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_punpckldq128 ((__v4si)__A, (__v4si)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_unpacklo_epi64 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_punpcklqdq128 ((__v2di)__A, (__v2di)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_add_epi8 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_paddb128 ((__v16qi)__A, (__v16qi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_add_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_paddw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_add_epi32 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_paddd128 ((__v4si)__A, (__v4si)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_add_epi64 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_paddq128 ((__v2di)__A, (__v2di)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_adds_epi8 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_paddsb128 ((__v16qi)__A, (__v16qi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_adds_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_paddsw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_adds_epu8 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_paddusb128 ((__v16qi)__A, (__v16qi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_adds_epu16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_paddusw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sub_epi8 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psubb128 ((__v16qi)__A, (__v16qi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sub_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psubw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sub_epi32 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psubd128 ((__v4si)__A, (__v4si)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sub_epi64 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psubq128 ((__v2di)__A, (__v2di)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_subs_epi8 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psubsb128 ((__v16qi)__A, (__v16qi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_subs_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psubsw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_subs_epu8 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psubusb128 ((__v16qi)__A, (__v16qi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_subs_epu16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psubusw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_madd_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pmaddwd128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_mulhi_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pmulhw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_mullo_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pmullw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_mul_su32 (__m64 __A, __m64 __B)
>{
> return (__m64)__builtin_ia32_pmuludq ((__v2si)__A, (__v2si)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_mul_epu32 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pmuludq128 ((__v4si)__A, (__v4si)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_slli_epi16 (__m128i __A, int __B)
>{
> return (__m128i)__builtin_ia32_psllwi128 ((__v8hi)__A, __B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_slli_epi32 (__m128i __A, int __B)
>{
> return (__m128i)__builtin_ia32_pslldi128 ((__v4si)__A, __B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_slli_epi64 (__m128i __A, int __B)
>{
> return (__m128i)__builtin_ia32_psllqi128 ((__v2di)__A, __B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srai_epi16 (__m128i __A, int __B)
>{
> return (__m128i)__builtin_ia32_psrawi128 ((__v8hi)__A, __B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srai_epi32 (__m128i __A, int __B)
>{
> return (__m128i)__builtin_ia32_psradi128 ((__v4si)__A, __B);
>}
>
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srli_si128 (__m128i __A, const int __N)
>{
> return (__m128i)__builtin_ia32_psrldqi128 (__A, __N * 8);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_slli_si128 (__m128i __A, const int __N)
>{
> return (__m128i)__builtin_ia32_pslldqi128 (__A, __N * 8);
>}
>
>
>
>
>
>
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srli_epi16 (__m128i __A, int __B)
>{
> return (__m128i)__builtin_ia32_psrlwi128 ((__v8hi)__A, __B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srli_epi32 (__m128i __A, int __B)
>{
> return (__m128i)__builtin_ia32_psrldi128 ((__v4si)__A, __B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srli_epi64 (__m128i __A, int __B)
>{
> return (__m128i)__builtin_ia32_psrlqi128 ((__v2di)__A, __B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sll_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psllw128((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sll_epi32 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pslld128((__v4si)__A, (__v4si)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sll_epi64 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psllq128((__v2di)__A, (__v2di)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sra_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psraw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sra_epi32 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psrad128 ((__v4si)__A, (__v4si)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srl_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psrlw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srl_epi32 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psrld128 ((__v4si)__A, (__v4si)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_srl_epi64 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psrlq128 ((__v2di)__A, (__v2di)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_and_si128 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pand128 ((__v2di)__A, (__v2di)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_andnot_si128 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pandn128 ((__v2di)__A, (__v2di)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_or_si128 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_por128 ((__v2di)__A, (__v2di)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_xor_si128 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pxor128 ((__v2di)__A, (__v2di)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpeq_epi8 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pcmpeqb128 ((__v16qi)__A, (__v16qi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpeq_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pcmpeqw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpeq_epi32 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pcmpeqd128 ((__v4si)__A, (__v4si)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmplt_epi8 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pcmpgtb128 ((__v16qi)__B, (__v16qi)__A);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmplt_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pcmpgtw128 ((__v8hi)__B, (__v8hi)__A);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmplt_epi32 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pcmpgtd128 ((__v4si)__B, (__v4si)__A);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpgt_epi8 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pcmpgtb128 ((__v16qi)__A, (__v16qi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpgt_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pcmpgtw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cmpgt_epi32 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pcmpgtd128 ((__v4si)__A, (__v4si)__B);
>}
>
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_extract_epi16 (__m128i const __A, int const __N)
>{
> return (unsigned short) __builtin_ia32_vec_ext_v8hi ((__v8hi)__A, __N);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_insert_epi16 (__m128i const __A, int const __D, int const __N)
>{
> return (__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)__A, __D, __N);
>}
># 1327 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/emmintrin.h" 3 4
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_max_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pmaxsw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_max_epu8 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pmaxub128 ((__v16qi)__A, (__v16qi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_min_epi16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pminsw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_min_epu8 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pminub128 ((__v16qi)__A, (__v16qi)__B);
>}
>
>extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_movemask_epi8 (__m128i __A)
>{
> return __builtin_ia32_pmovmskb128 ((__v16qi)__A);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_mulhi_epu16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pmulhuw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_shufflehi_epi16 (__m128i __A, const int __mask)
>{
> return (__m128i)__builtin_ia32_pshufhw ((__v8hi)__A, __mask);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_shufflelo_epi16 (__m128i __A, const int __mask)
>{
> return (__m128i)__builtin_ia32_pshuflw ((__v8hi)__A, __mask);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_shuffle_epi32 (__m128i __A, const int __mask)
>{
> return (__m128i)__builtin_ia32_pshufd ((__v4si)__A, __mask);
>}
># 1390 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/emmintrin.h" 3 4
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_maskmoveu_si128 (__m128i __A, __m128i __B, char *__C)
>{
> __builtin_ia32_maskmovdqu ((__v16qi)__A, (__v16qi)__B, __C);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_avg_epu8 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pavgb128 ((__v16qi)__A, (__v16qi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_avg_epu16 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_pavgw128 ((__v8hi)__A, (__v8hi)__B);
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_sad_epu8 (__m128i __A, __m128i __B)
>{
> return (__m128i)__builtin_ia32_psadbw128 ((__v16qi)__A, (__v16qi)__B);
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_stream_si32 (int *__A, int __B)
>{
> __builtin_ia32_movnti (__A, __B);
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_stream_si64 (long long int *__A, long long int __B)
>{
> __builtin_ia32_movnti64 (__A, __B);
>}
>
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_stream_si128 (__m128i *__A, __m128i __B)
>{
> __builtin_ia32_movntdq ((__v2di *)__A, (__v2di)__B);
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_stream_pd (double *__A, __m128d __B)
>{
> __builtin_ia32_movntpd (__A, (__v2df)__B);
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_clflush (void const *__A)
>{
> __builtin_ia32_clflush (__A);
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_lfence (void)
>{
> __builtin_ia32_lfence ();
>}
>
>extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_mfence (void)
>{
> __builtin_ia32_mfence ();
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi32_si128 (int __A)
>{
> return _mm_set_epi32 (0, 0, 0, __A);
>}
>
>
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi64_si128 (long long __A)
>{
> return _mm_set_epi64x (0, __A);
>}
>
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_cvtsi64x_si128 (long long __A)
>{
> return _mm_set_epi64x (0, __A);
>}
>
>
>
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_castpd_ps(__m128d __A)
>{
> return (__m128) __A;
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_castpd_si128(__m128d __A)
>{
> return (__m128i) __A;
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_castps_pd(__m128 __A)
>{
> return (__m128d) __A;
>}
>
>extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_castps_si128(__m128 __A)
>{
> return (__m128i) __A;
>}
>
>extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_castsi128_ps(__m128i __A)
>{
> return (__m128) __A;
>}
>
>extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_mm_castsi128_pd(__m128i __A)
>{
> return (__m128d) __A;
>}
># 1247 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/xmmintrin.h" 2 3 4
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/x86intrin.h" 2 3 4
># 62 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/x86intrin.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/immintrin.h" 1 3 4
># 63 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/x86intrin.h" 2 3 4
># 109 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/x86intrin.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/fxsrintrin.h" 1 3 4
># 31 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/fxsrintrin.h" 3 4
>extern __inline void
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_fxsave (void *__P)
>{
> return __builtin_ia32_fxsave (__P);
>}
>
>extern __inline void
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_fxrstor (void *__P)
>{
> return __builtin_ia32_fxrstor (__P);
>}
>
>
>extern __inline void
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_fxsave64 (void *__P)
>{
> return __builtin_ia32_fxsave64 (__P);
>}
>
>extern __inline void
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_fxrstor64 (void *__P)
>{
> return __builtin_ia32_fxrstor64 (__P);
>}
># 110 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/x86intrin.h" 2 3 4
># 120 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/x86intrin.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/adxintrin.h" 1 3 4
># 31 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/adxintrin.h" 3 4
>extern __inline unsigned char
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_addcarryx_u32 (unsigned char __CF, unsigned int __X,
> unsigned int __Y, unsigned int *__P)
>{
> return __builtin_ia32_addcarryx_u32 (__CF, __X, __Y, __P);
>}
>
>
>extern __inline unsigned char
>__attribute__((__gnu_inline__, __always_inline__, __artificial__))
>_addcarryx_u64 (unsigned char __CF, unsigned long __X,
> unsigned long __Y, unsigned long long *__P)
>{
> return __builtin_ia32_addcarryx_u64 (__CF, __X, __Y, __P);
>}
># 121 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/x86intrin.h" 2 3 4
># 34 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/opt_random.h" 2 3
>
>
> 
># 37 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/opt_random.h" 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 215 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/opt_random.h" 3
>
>}
># 52 "/usr/include/c++/4.8.2/random" 2 3
># 1 "/usr/include/c++/4.8.2/bits/random.tcc" 1 3
># 33 "/usr/include/c++/4.8.2/bits/random.tcc" 3
># 1 "/usr/include/c++/4.8.2/numeric" 1 3
># 58 "/usr/include/c++/4.8.2/numeric" 3
> 
># 59 "/usr/include/c++/4.8.2/numeric" 3
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/stl_numeric.h" 1 3
># 65 "/usr/include/c++/4.8.2/bits/stl_numeric.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 80 "/usr/include/c++/4.8.2/bits/stl_numeric.h" 3
> template<typename _ForwardIterator, typename _Tp>
> void
> iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
> {
>
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> {
> *__first = __value;
> ++__value;
> }
> }
>
>
>}
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 118 "/usr/include/c++/4.8.2/bits/stl_numeric.h" 3
> template<typename _InputIterator, typename _Tp>
> inline _Tp
> accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
> {
>
> 
> ;
>
> for (; __first != __last; ++__first)
> __init = __init + *__first;
> return __init;
> }
># 144 "/usr/include/c++/4.8.2/bits/stl_numeric.h" 3
> template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
> inline _Tp
> accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
> _BinaryOperation __binary_op)
> {
>
> 
> ;
>
> for (; __first != __last; ++__first)
> __init = __binary_op(__init, *__first);
> return __init;
> }
># 172 "/usr/include/c++/4.8.2/bits/stl_numeric.h" 3
> template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
> inline _Tp
> inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _Tp __init)
> {
>
> 
> 
> ;
>
> for (; __first1 != __last1; ++__first1, ++__first2)
> __init = __init + (*__first1 * *__first2);
> return __init;
> }
># 203 "/usr/include/c++/4.8.2/bits/stl_numeric.h" 3
> template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
> typename _BinaryOperation1, typename _BinaryOperation2>
> inline _Tp
> inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _Tp __init,
> _BinaryOperation1 __binary_op1,
> _BinaryOperation2 __binary_op2)
> {
>
> 
> 
> ;
>
> for (; __first1 != __last1; ++__first1, ++__first2)
> __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
> return __init;
> }
># 235 "/usr/include/c++/4.8.2/bits/stl_numeric.h" 3
> template<typename _InputIterator, typename _OutputIterator>
> _OutputIterator
> partial_sum(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result)
> {
> typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
>
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __result;
> _ValueType __value = *__first;
> *__result = __value;
> while (++__first != __last)
> {
> __value = __value + *__first;
> *++__result = __value;
> }
> return ++__result;
> }
># 275 "/usr/include/c++/4.8.2/bits/stl_numeric.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _BinaryOperation>
> _OutputIterator
> partial_sum(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _BinaryOperation __binary_op)
> {
> typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
>
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __result;
> _ValueType __value = *__first;
> *__result = __value;
> while (++__first != __last)
> {
> __value = __binary_op(__value, *__first);
> *++__result = __value;
> }
> return ++__result;
> }
># 315 "/usr/include/c++/4.8.2/bits/stl_numeric.h" 3
> template<typename _InputIterator, typename _OutputIterator>
> _OutputIterator
> adjacent_difference(_InputIterator __first,
> _InputIterator __last, _OutputIterator __result)
> {
> typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
>
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __result;
> _ValueType __value = *__first;
> *__result = __value;
> while (++__first != __last)
> {
> _ValueType __tmp = *__first;
> *++__result = __tmp - __value;
> __value = std::move(__tmp);
> }
> return ++__result;
> }
># 357 "/usr/include/c++/4.8.2/bits/stl_numeric.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _BinaryOperation>
> _OutputIterator
> adjacent_difference(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _BinaryOperation __binary_op)
> {
> typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
>
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __result;
> _ValueType __value = *__first;
> *__result = __value;
> while (++__first != __last)
> {
> _ValueType __tmp = *__first;
> *++__result = __binary_op(__tmp, __value);
> __value = std::move(__tmp);
> }
> return ++__result;
> }
>
>
>}
># 63 "/usr/include/c++/4.8.2/numeric" 2 3
># 34 "/usr/include/c++/4.8.2/bits/random.tcc" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> namespace __detail
> {
> 
>
>
>
>
>
>
>
> template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
> _Tp
> _Mod<_Tp, __m, __a, __c, false, true>::
> __calc(_Tp __x)
> {
> if (__a == 1)
> __x %= __m;
> else
> {
> static const _Tp __q = __m / __a;
> static const _Tp __r = __m % __a;
>
> _Tp __t1 = __a * (__x % __q);
> _Tp __t2 = __r * (__x / __q);
> if (__t1 >= __t2)
> __x = __t1 - __t2;
> else
> __x = __m - __t2 + __t1;
> }
>
> if (__c != 0)
> {
> const _Tp __d = __m - __x;
> if (__d > __c)
> __x += __c;
> else
> __x = __c - __d;
> }
> return __x;
> }
>
> template<typename _InputIterator, typename _OutputIterator,
> typename _Tp>
> _OutputIterator
> __normalize(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, const _Tp& __factor)
> {
> for (; __first != __last; ++__first, ++__result)
> *__result = *__first / __factor;
> return __result;
> }
>
> 
> }
>
>
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> constexpr _UIntType
> linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier;
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> constexpr _UIntType
> linear_congruential_engine<_UIntType, __a, __c, __m>::increment;
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> constexpr _UIntType
> linear_congruential_engine<_UIntType, __a, __c, __m>::modulus;
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> constexpr _UIntType
> linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed;
>
>
>
>
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> void
> linear_congruential_engine<_UIntType, __a, __c, __m>::
> seed(result_type __s)
> {
> if ((__detail::__mod<_UIntType, __m>(__c) == 0)
> && (__detail::__mod<_UIntType, __m>(__s) == 0))
> _M_x = 1;
> else
> _M_x = __detail::__mod<_UIntType, __m>(__s);
> }
>
>
>
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> template<typename _Sseq>
> typename std::enable_if<std::is_class<_Sseq>::value>::type
> linear_congruential_engine<_UIntType, __a, __c, __m>::
> seed(_Sseq& __q)
> {
> const _UIntType __k0 = __m == 0 ? std::numeric_limits<_UIntType>::digits
> : std::__lg(__m);
> const _UIntType __k = (__k0 + 31) / 32;
> uint_least32_t __arr[__k + 3];
> __q.generate(__arr + 0, __arr + __k + 3);
> _UIntType __factor = 1u;
> _UIntType __sum = 0u;
> for (size_t __j = 0; __j < __k; ++__j)
> {
> __sum += __arr[__j + 3] * __factor;
> __factor *= __detail::_Shift<_UIntType, 32>::__value;
> }
> seed(__sum);
> }
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const linear_congruential_engine<_UIntType,
> __a, __c, __m>& __lcr)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
> __os.fill(__os.widen(' '));
>
> __os << __lcr._M_x;
>
> __os.flags(__flags);
> __os.fill(__fill);
> return __os;
> }
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> linear_congruential_engine<_UIntType, __a, __c, __m>& __lcr)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec);
>
> __is >> __lcr._M_x;
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::word_size;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::state_size;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::shift_size;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::mask_bits;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr _UIntType
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::xor_mask;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::tempering_u;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr _UIntType
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::tempering_d;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::tempering_s;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr _UIntType
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::tempering_b;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::tempering_t;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr _UIntType
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::tempering_c;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::tempering_l;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr _UIntType
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::
> initialization_multiplier;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr _UIntType
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::default_seed;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> void
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::
> seed(result_type __sd)
> {
> _M_x[0] = __detail::__mod<_UIntType,
> __detail::_Shift<_UIntType, __w>::__value>(__sd);
>
> for (size_t __i = 1; __i < state_size; ++__i)
> {
> _UIntType __x = _M_x[__i - 1];
> __x ^= __x >> (__w - 2);
> __x *= __f;
> __x += __detail::__mod<_UIntType, __n>(__i);
> _M_x[__i] = __detail::__mod<_UIntType,
> __detail::_Shift<_UIntType, __w>::__value>(__x);
> }
> _M_p = state_size;
> }
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> template<typename _Sseq>
> typename std::enable_if<std::is_class<_Sseq>::value>::type
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::
> seed(_Sseq& __q)
> {
> const _UIntType __upper_mask = (~_UIntType()) << __r;
> const size_t __k = (__w + 31) / 32;
> uint_least32_t __arr[__n * __k];
> __q.generate(__arr + 0, __arr + __n * __k);
>
> bool __zero = true;
> for (size_t __i = 0; __i < state_size; ++__i)
> {
> _UIntType __factor = 1u;
> _UIntType __sum = 0u;
> for (size_t __j = 0; __j < __k; ++__j)
> {
> __sum += __arr[__k * __i + __j] * __factor;
> __factor *= __detail::_Shift<_UIntType, 32>::__value;
> }
> _M_x[__i] = __detail::__mod<_UIntType,
> __detail::_Shift<_UIntType, __w>::__value>(__sum);
>
> if (__zero)
> {
> if (__i == 0)
> {
> if ((_M_x[0] & __upper_mask) != 0u)
> __zero = false;
> }
> else if (_M_x[__i] != 0u)
> __zero = false;
> }
> }
> if (__zero)
> _M_x[0] = __detail::_Shift<_UIntType, __w - 1>::__value;
> _M_p = state_size;
> }
>
> template<typename _UIntType, size_t __w,
> size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> void
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::
> _M_gen_rand(void)
> {
> const _UIntType __upper_mask = (~_UIntType()) << __r;
> const _UIntType __lower_mask = ~__upper_mask;
>
> for (size_t __k = 0; __k < (__n - __m); ++__k)
> {
> _UIntType __y = ((_M_x[__k] & __upper_mask)
> | (_M_x[__k + 1] & __lower_mask));
> _M_x[__k] = (_M_x[__k + __m] ^ (__y >> 1)
> ^ ((__y & 0x01) ? __a : 0));
> }
>
> for (size_t __k = (__n - __m); __k < (__n - 1); ++__k)
> {
> _UIntType __y = ((_M_x[__k] & __upper_mask)
> | (_M_x[__k + 1] & __lower_mask));
> _M_x[__k] = (_M_x[__k + (__m - __n)] ^ (__y >> 1)
> ^ ((__y & 0x01) ? __a : 0));
> }
>
> _UIntType __y = ((_M_x[__n - 1] & __upper_mask)
> | (_M_x[0] & __lower_mask));
> _M_x[__n - 1] = (_M_x[__m - 1] ^ (__y >> 1)
> ^ ((__y & 0x01) ? __a : 0));
> _M_p = 0;
> }
>
> template<typename _UIntType, size_t __w,
> size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> void
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::
> discard(unsigned long long __z)
> {
> while (__z > state_size - _M_p)
> {
> __z -= state_size - _M_p;
> _M_gen_rand();
> }
> _M_p += __z;
> }
>
> template<typename _UIntType, size_t __w,
> size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> typename
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::result_type
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::
> operator()()
> {
>
> if (_M_p >= state_size)
> _M_gen_rand();
>
>
> result_type __z = _M_x[_M_p++];
> __z ^= (__z >> __u) & __d;
> __z ^= (__z << __s) & __b;
> __z ^= (__z << __t) & __c;
> __z ^= (__z >> __l);
>
> return __z;
> }
>
> template<typename _UIntType, size_t __w,
> size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const mersenne_twister_engine<_UIntType, __w, __n, __m,
> __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
> __os.fill(__space);
>
> for (size_t __i = 0; __i < __n; ++__i)
> __os << __x._M_x[__i] << __space;
> __os << __x._M_p;
>
> __os.flags(__flags);
> __os.fill(__fill);
> return __os;
> }
>
> template<typename _UIntType, size_t __w,
> size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> mersenne_twister_engine<_UIntType, __w, __n, __m,
> __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> for (size_t __i = 0; __i < __n; ++__i)
> __is >> __x._M_x[__i];
> __is >> __x._M_p;
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> constexpr size_t
> subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> constexpr size_t
> subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> constexpr size_t
> subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> constexpr _UIntType
> subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> void
> subtract_with_carry_engine<_UIntType, __w, __s, __r>::
> seed(result_type __value)
> {
> std::linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
> __lcg(__value == 0u ? default_seed : __value);
>
> const size_t __n = (__w + 31) / 32;
>
> for (size_t __i = 0; __i < long_lag; ++__i)
> {
> _UIntType __sum = 0u;
> _UIntType __factor = 1u;
> for (size_t __j = 0; __j < __n; ++__j)
> {
> __sum += __detail::__mod<uint_least32_t,
> __detail::_Shift<uint_least32_t, 32>::__value>
> (__lcg()) * __factor;
> __factor *= __detail::_Shift<_UIntType, 32>::__value;
> }
> _M_x[__i] = __detail::__mod<_UIntType,
> __detail::_Shift<_UIntType, __w>::__value>(__sum);
> }
> _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
> _M_p = 0;
> }
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> template<typename _Sseq>
> typename std::enable_if<std::is_class<_Sseq>::value>::type
> subtract_with_carry_engine<_UIntType, __w, __s, __r>::
> seed(_Sseq& __q)
> {
> const size_t __k = (__w + 31) / 32;
> uint_least32_t __arr[__r * __k];
> __q.generate(__arr + 0, __arr + __r * __k);
>
> for (size_t __i = 0; __i < long_lag; ++__i)
> {
> _UIntType __sum = 0u;
> _UIntType __factor = 1u;
> for (size_t __j = 0; __j < __k; ++__j)
> {
> __sum += __arr[__k * __i + __j] * __factor;
> __factor *= __detail::_Shift<_UIntType, 32>::__value;
> }
> _M_x[__i] = __detail::__mod<_UIntType,
> __detail::_Shift<_UIntType, __w>::__value>(__sum);
> }
> _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
> _M_p = 0;
> }
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> typename subtract_with_carry_engine<_UIntType, __w, __s, __r>::
> result_type
> subtract_with_carry_engine<_UIntType, __w, __s, __r>::
> operator()()
> {
>
> long __ps = _M_p - short_lag;
> if (__ps < 0)
> __ps += long_lag;
>
>
>
>
> _UIntType __xi;
> if (_M_x[__ps] >= _M_x[_M_p] + _M_carry)
> {
> __xi = _M_x[__ps] - _M_x[_M_p] - _M_carry;
> _M_carry = 0;
> }
> else
> {
> __xi = (__detail::_Shift<_UIntType, __w>::__value
> - _M_x[_M_p] - _M_carry + _M_x[__ps]);
> _M_carry = 1;
> }
> _M_x[_M_p] = __xi;
>
>
> if (++_M_p >= long_lag)
> _M_p = 0;
>
> return __xi;
> }
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const subtract_with_carry_engine<_UIntType,
> __w, __s, __r>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
> __os.fill(__space);
>
> for (size_t __i = 0; __i < __r; ++__i)
> __os << __x._M_x[__i] << __space;
> __os << __x._M_carry << __space << __x._M_p;
>
> __os.flags(__flags);
> __os.fill(__fill);
> return __os;
> }
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> subtract_with_carry_engine<_UIntType, __w, __s, __r>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> for (size_t __i = 0; __i < __r; ++__i)
> __is >> __x._M_x[__i];
> __is >> __x._M_carry;
> __is >> __x._M_p;
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RandomNumberEngine, size_t __p, size_t __r>
> constexpr size_t
> discard_block_engine<_RandomNumberEngine, __p, __r>::block_size;
>
> template<typename _RandomNumberEngine, size_t __p, size_t __r>
> constexpr size_t
> discard_block_engine<_RandomNumberEngine, __p, __r>::used_block;
>
> template<typename _RandomNumberEngine, size_t __p, size_t __r>
> typename discard_block_engine<_RandomNumberEngine,
> __p, __r>::result_type
> discard_block_engine<_RandomNumberEngine, __p, __r>::
> operator()()
> {
> if (_M_n >= used_block)
> {
> _M_b.discard(block_size - _M_n);
> _M_n = 0;
> }
> ++_M_n;
> return _M_b();
> }
>
> template<typename _RandomNumberEngine, size_t __p, size_t __r,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const discard_block_engine<_RandomNumberEngine,
> __p, __r>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
> __os.fill(__space);
>
> __os << __x.base() << __space << __x._M_n;
>
> __os.flags(__flags);
> __os.fill(__fill);
> return __os;
> }
>
> template<typename _RandomNumberEngine, size_t __p, size_t __r,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> discard_block_engine<_RandomNumberEngine, __p, __r>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> __is >> __x._M_b >> __x._M_n;
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
> typename independent_bits_engine<_RandomNumberEngine, __w, _UIntType>::
> result_type
> independent_bits_engine<_RandomNumberEngine, __w, _UIntType>::
> operator()()
> {
> typedef typename _RandomNumberEngine::result_type _Eresult_type;
> const _Eresult_type __r
> = (_M_b.max() - _M_b.min() < std::numeric_limits<_Eresult_type>::max()
> ? _M_b.max() - _M_b.min() + 1 : 0);
> const unsigned __edig = std::numeric_limits<_Eresult_type>::digits;
> const unsigned __m = __r ? std::__lg(__r) : __edig;
>
> typedef typename std::common_type<_Eresult_type, result_type>::type
> __ctype;
> const unsigned __cdig = std::numeric_limits<__ctype>::digits;
>
> unsigned __n, __n0;
> __ctype __s0, __s1, __y0, __y1;
>
> for (size_t __i = 0; __i < 2; ++__i)
> {
> __n = (__w + __m - 1) / __m + __i;
> __n0 = __n - __w % __n;
> const unsigned __w0 = __w / __n;
>
> __s0 = 0;
> __s1 = 0;
> if (__w0 < __cdig)
> {
> __s0 = __ctype(1) << __w0;
> __s1 = __s0 << 1;
> }
>
> __y0 = 0;
> __y1 = 0;
> if (__r)
> {
> __y0 = __s0 * (__r / __s0);
> if (__s1)
> __y1 = __s1 * (__r / __s1);
>
> if (__r - __y0 <= __y0 / __n)
> break;
> }
> else
> break;
> }
>
> result_type __sum = 0;
> for (size_t __k = 0; __k < __n0; ++__k)
> {
> __ctype __u;
> do
> __u = _M_b() - _M_b.min();
> while (__y0 && __u >= __y0);
> __sum = __s0 * __sum + (__s0 ? __u % __s0 : __u);
> }
> for (size_t __k = __n0; __k < __n; ++__k)
> {
> __ctype __u;
> do
> __u = _M_b() - _M_b.min();
> while (__y1 && __u >= __y1);
> __sum = __s1 * __sum + (__s1 ? __u % __s1 : __u);
> }
> return __sum;
> }
>
>
> template<typename _RandomNumberEngine, size_t __k>
> constexpr size_t
> shuffle_order_engine<_RandomNumberEngine, __k>::table_size;
>
> template<typename _RandomNumberEngine, size_t __k>
> typename shuffle_order_engine<_RandomNumberEngine, __k>::result_type
> shuffle_order_engine<_RandomNumberEngine, __k>::
> operator()()
> {
> size_t __j = __k * ((_M_y - _M_b.min())
> / (_M_b.max() - _M_b.min() + 1.0L));
> _M_y = _M_v[__j];
> _M_v[__j] = _M_b();
>
> return _M_y;
> }
>
> template<typename _RandomNumberEngine, size_t __k,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const shuffle_order_engine<_RandomNumberEngine, __k>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
> __os.fill(__space);
>
> __os << __x.base();
> for (size_t __i = 0; __i < __k; ++__i)
> __os << __space << __x._M_v[__i];
> __os << __space << __x._M_y;
>
> __os.flags(__flags);
> __os.fill(__fill);
> return __os;
> }
>
> template<typename _RandomNumberEngine, size_t __k,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> shuffle_order_engine<_RandomNumberEngine, __k>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> __is >> __x._M_b;
> for (size_t __i = 0; __i < __k; ++__i)
> __is >> __x._M_v[__i];
> __is >> __x._M_y;
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename uniform_int_distribution<_IntType>::result_type
> uniform_int_distribution<_IntType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> typedef typename _UniformRandomNumberGenerator::result_type
> _Gresult_type;
> typedef typename std::make_unsigned<result_type>::type __utype;
> typedef typename std::common_type<_Gresult_type, __utype>::type
> __uctype;
>
> const __uctype __urngmin = __urng.min();
> const __uctype __urngmax = __urng.max();
> const __uctype __urngrange = __urngmax - __urngmin;
> const __uctype __urange
> = __uctype(__param.b()) - __uctype(__param.a());
>
> __uctype __ret;
>
> if (__urngrange > __urange)
> {
>
> const __uctype __uerange = __urange + 1;
> const __uctype __scaling = __urngrange / __uerange;
> const __uctype __past = __uerange * __scaling;
> do
> __ret = __uctype(__urng()) - __urngmin;
> while (__ret >= __past);
> __ret /= __scaling;
> }
> else if (__urngrange < __urange)
> {
># 924 "/usr/include/c++/4.8.2/bits/random.tcc" 3
> __uctype __tmp;
> do
> {
> const __uctype __uerngrange = __urngrange + 1;
> __tmp = (__uerngrange * operator()
> (__urng, param_type(0, __urange / __uerngrange)));
> __ret = __tmp + (__uctype(__urng()) - __urngmin);
> }
> while (__ret > __urange || __ret < __tmp);
> }
> else
> __ret = __uctype(__urng()) - __urngmin;
>
> return __ret + __param.a();
> }
>
>
> template<typename _IntType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> uniform_int_distribution<_IntType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
>
> typedef typename _UniformRandomNumberGenerator::result_type
> _Gresult_type;
> typedef typename std::make_unsigned<result_type>::type __utype;
> typedef typename std::common_type<_Gresult_type, __utype>::type
> __uctype;
>
> const __uctype __urngmin = __urng.min();
> const __uctype __urngmax = __urng.max();
> const __uctype __urngrange = __urngmax - __urngmin;
> const __uctype __urange
> = __uctype(__param.b()) - __uctype(__param.a());
>
> __uctype __ret;
>
> if (__urngrange > __urange)
> {
> if (__detail::_Power_of_2(__urngrange + 1)
> && __detail::_Power_of_2(__urange + 1))
> {
> while (__f != __t)
> {
> __ret = __uctype(__urng()) - __urngmin;
> *__f++ = (__ret & __urange) + __param.a();
> }
> }
> else
> {
>
> const __uctype __uerange = __urange + 1;
> const __uctype __scaling = __urngrange / __uerange;
> const __uctype __past = __uerange * __scaling;
> while (__f != __t)
> {
> do
> __ret = __uctype(__urng()) - __urngmin;
> while (__ret >= __past);
> *__f++ = __ret / __scaling + __param.a();
> }
> }
> }
> else if (__urngrange < __urange)
> {
># 1008 "/usr/include/c++/4.8.2/bits/random.tcc" 3
> __uctype __tmp;
> while (__f != __t)
> {
> do
> {
> const __uctype __uerngrange = __urngrange + 1;
> __tmp = (__uerngrange * operator()
> (__urng, param_type(0, __urange / __uerngrange)));
> __ret = __tmp + (__uctype(__urng()) - __urngmin);
> }
> while (__ret > __urange || __ret < __tmp);
> *__f++ = __ret;
> }
> }
> else
> while (__f != __t)
> *__f++ = __uctype(__urng()) - __urngmin + __param.a();
> }
>
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const uniform_int_distribution<_IntType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
>
> __os << __x.a() << __space << __x.b();
>
> __os.flags(__flags);
> __os.fill(__fill);
> return __os;
> }
>
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> uniform_int_distribution<_IntType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _IntType __a, __b;
> __is >> __a >> __b;
> __x.param(typename uniform_int_distribution<_IntType>::
> param_type(__a, __b));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> uniform_real_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
>
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
> auto __range = __p.b() - __p.a();
> while (__f != __t)
> *__f++ = __aurng() * __range + __p.a();
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const uniform_real_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.a() << __space << __x.b();
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> uniform_real_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::skipws);
>
> _RealType __a, __b;
> __is >> __a >> __b;
> __x.param(typename uniform_real_distribution<_RealType>::
> param_type(__a, __b));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> std::bernoulli_distribution::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> 
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
> auto __limit = __p.p() * (__aurng.max() - __aurng.min());
>
> while (__f != __t)
> *__f++ = (__aurng() - __aurng.min()) < __limit;
> }
>
> template<typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const bernoulli_distribution& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__os.widen(' '));
> __os.precision(std::numeric_limits<double>::max_digits10);
>
> __os << __x.p();
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
>
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename geometric_distribution<_IntType>::result_type
> geometric_distribution<_IntType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
>
>
> const double __naf =
> (1 - std::numeric_limits<double>::epsilon()) / 2;
>
> const double __thr =
> std::numeric_limits<_IntType>::max() + __naf;
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
> double __cand;
> do
> __cand = std::floor(std::log(1.0 - __aurng()) / __param._M_log_1_p);
> while (__cand >= __thr);
>
> return result_type(__cand + __naf);
> }
>
> template<typename _IntType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> geometric_distribution<_IntType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
>
>
>
> const double __naf =
> (1 - std::numeric_limits<double>::epsilon()) / 2;
>
> const double __thr =
> std::numeric_limits<_IntType>::max() + __naf;
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
> while (__f != __t)
> {
> double __cand;
> do
> __cand = std::floor(std::log(1.0 - __aurng())
> / __param._M_log_1_p);
> while (__cand >= __thr);
>
> *__f++ = __cand + __naf;
> }
> }
>
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const geometric_distribution<_IntType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__os.widen(' '));
> __os.precision(std::numeric_limits<double>::max_digits10);
>
> __os << __x.p();
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> geometric_distribution<_IntType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::skipws);
>
> double __p;
> __is >> __p;
> __x.param(typename geometric_distribution<_IntType>::param_type(__p));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename negative_binomial_distribution<_IntType>::result_type
> negative_binomial_distribution<_IntType>::
> operator()(_UniformRandomNumberGenerator& __urng)
> {
> const double __y = _M_gd(__urng);
>
>
> std::poisson_distribution<result_type> __poisson(__y);
> return __poisson(__urng);
> }
>
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename negative_binomial_distribution<_IntType>::result_type
> negative_binomial_distribution<_IntType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> typedef typename std::gamma_distribution<double>::param_type
> param_type;
>
> const double __y =
> _M_gd(__urng, param_type(__p.k(), (1.0 - __p.p()) / __p.p()));
>
> std::poisson_distribution<result_type> __poisson(__y);
> return __poisson(__urng);
> }
>
> template<typename _IntType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> negative_binomial_distribution<_IntType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> {
>
> while (__f != __t)
> {
> const double __y = _M_gd(__urng);
>
>
> std::poisson_distribution<result_type> __poisson(__y);
> *__f++ = __poisson(__urng);
> }
> }
>
> template<typename _IntType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> negative_binomial_distribution<_IntType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
>
> typename std::gamma_distribution<result_type>::param_type
> __p2(__p.k(), (1.0 - __p.p()) / __p.p());
>
> while (__f != __t)
> {
> const double __y = _M_gd(__urng, __p2);
>
> std::poisson_distribution<result_type> __poisson(__y);
> *__f++ = __poisson(__urng);
> }
> }
>
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const negative_binomial_distribution<_IntType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__os.widen(' '));
> __os.precision(std::numeric_limits<double>::max_digits10);
>
> __os << __x.k() << __space << __x.p()
> << __space << __x._M_gd;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> negative_binomial_distribution<_IntType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::skipws);
>
> _IntType __k;
> double __p;
> __is >> __k >> __p >> __x._M_gd;
> __x.param(typename negative_binomial_distribution<_IntType>::
> param_type(__k, __p));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _IntType>
> void
> poisson_distribution<_IntType>::param_type::
> _M_initialize()
> {
>
> if (_M_mean >= 12)
> {
> const double __m = std::floor(_M_mean);
> _M_lm_thr = std::log(_M_mean);
> _M_lfm = std::lgamma(__m + 1);
> _M_sm = std::sqrt(__m);
>
> const double __pi_4 = 0.7853981633974483096156608458198757L;
> const double __dx = std::sqrt(2 * __m * std::log(32 * __m
> / __pi_4));
> _M_d = std::round(std::max(6.0, std::min(__m, __dx)));
> const double __cx = 2 * __m + _M_d;
> _M_scx = std::sqrt(__cx / 2);
> _M_1cx = 1 / __cx;
>
> _M_c2b = std::sqrt(__pi_4 * __cx) * std::exp(_M_1cx);
> _M_cb = 2 * __cx * std::exp(-_M_d * _M_1cx * (1 + _M_d / 2))
> / _M_d;
> }
> else
>
> _M_lm_thr = std::exp(-_M_mean);
> }
># 1432 "/usr/include/c++/4.8.2/bits/random.tcc" 3
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename poisson_distribution<_IntType>::result_type
> poisson_distribution<_IntType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
> if (__param.mean() >= 12)
> {
> double __x;
>
>
> const double __naf =
> (1 - std::numeric_limits<double>::epsilon()) / 2;
> const double __thr =
> std::numeric_limits<_IntType>::max() + __naf;
>
> const double __m = std::floor(__param.mean());
>
> const double __spi_2 = 1.2533141373155002512078826424055226L;
> const double __c1 = __param._M_sm * __spi_2;
> const double __c2 = __param._M_c2b + __c1;
> const double __c3 = __c2 + 1;
> const double __c4 = __c3 + 1;
>
> const double __e178 = 1.0129030479320018583185514777512983L;
> const double __c5 = __c4 + __e178;
> const double __c = __param._M_cb + __c5;
> const double __2cx = 2 * (2 * __m + __param._M_d);
>
> bool __reject = true;
> do
> {
> const double __u = __c * __aurng();
> const double __e = -std::log(1.0 - __aurng());
>
> double __w = 0.0;
>
> if (__u <= __c1)
> {
> const double __n = _M_nd(__urng);
> const double __y = -std::abs(__n) * __param._M_sm - 1;
> __x = std::floor(__y);
> __w = -__n * __n / 2;
> if (__x < -__m)
> continue;
> }
> else if (__u <= __c2)
> {
> const double __n = _M_nd(__urng);
> const double __y = 1 + std::abs(__n) * __param._M_scx;
> __x = std::ceil(__y);
> __w = __y * (2 - __y) * __param._M_1cx;
> if (__x > __param._M_d)
> continue;
> }
> else if (__u <= __c3)
>
>
> __x = -1;
> else if (__u <= __c4)
> __x = 0;
> else if (__u <= __c5)
> __x = 1;
> else
> {
> const double __v = -std::log(1.0 - __aurng());
> const double __y = __param._M_d
> + __v * __2cx / __param._M_d;
> __x = std::ceil(__y);
> __w = -__param._M_d * __param._M_1cx * (1 + __y / 2);
> }
>
> __reject = (__w - __e - __x * __param._M_lm_thr
> > __param._M_lfm - std::lgamma(__x + __m + 1));
>
> __reject |= __x + __m >= __thr;
>
> } while (__reject);
>
> return result_type(__x + __m + __naf);
> }
> else
>
> {
> _IntType __x = 0;
> double __prod = 1.0;
>
> do
> {
> __prod *= __aurng();
> __x += 1;
> }
> while (__prod > __param._M_lm_thr);
>
> return __x - 1;
> }
> }
>
> template<typename _IntType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> poisson_distribution<_IntType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
>
>
> while (__f != __t)
> *__f++ = this->operator()(__urng, __param);
> }
>
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const poisson_distribution<_IntType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<double>::max_digits10);
>
> __os << __x.mean() << __space << __x._M_nd;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> poisson_distribution<_IntType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::skipws);
>
> double __mean;
> __is >> __mean >> __x._M_nd;
> __x.param(typename poisson_distribution<_IntType>::param_type(__mean));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _IntType>
> void
> binomial_distribution<_IntType>::param_type::
> _M_initialize()
> {
> const double __p12 = _M_p <= 0.5 ? _M_p : 1.0 - _M_p;
>
> _M_easy = true;
>
>
> if (_M_t * __p12 >= 8)
> {
> _M_easy = false;
> const double __np = std::floor(_M_t * __p12);
> const double __pa = __np / _M_t;
> const double __1p = 1 - __pa;
>
> const double __pi_4 = 0.7853981633974483096156608458198757L;
> const double __d1x =
> std::sqrt(__np * __1p * std::log(32 * __np
> / (81 * __pi_4 * __1p)));
> _M_d1 = std::round(std::max(1.0, __d1x));
> const double __d2x =
> std::sqrt(__np * __1p * std::log(32 * _M_t * __1p
> / (__pi_4 * __pa)));
> _M_d2 = std::round(std::max(1.0, __d2x));
>
>
> const double __spi_2 = 1.2533141373155002512078826424055226L;
> _M_s1 = std::sqrt(__np * __1p) * (1 + _M_d1 / (4 * __np));
> _M_s2 = std::sqrt(__np * __1p) * (1 + _M_d2 / (4 * _M_t * __1p));
> _M_c = 2 * _M_d1 / __np;
> _M_a1 = std::exp(_M_c) * _M_s1 * __spi_2;
> const double __a12 = _M_a1 + _M_s2 * __spi_2;
> const double __s1s = _M_s1 * _M_s1;
> _M_a123 = __a12 + (std::exp(_M_d1 / (_M_t * __1p))
> * 2 * __s1s / _M_d1
> * std::exp(-_M_d1 * _M_d1 / (2 * __s1s)));
> const double __s2s = _M_s2 * _M_s2;
> _M_s = (_M_a123 + 2 * __s2s / _M_d2
> * std::exp(-_M_d2 * _M_d2 / (2 * __s2s)));
> _M_lf = (std::lgamma(__np + 1)
> + std::lgamma(_M_t - __np + 1));
> _M_lp1p = std::log(__pa / __1p);
>
> _M_q = -std::log(1 - (__p12 - __pa) / __1p);
> }
> else
>
> _M_q = -std::log(1 - __p12);
> }
>
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename binomial_distribution<_IntType>::result_type
> binomial_distribution<_IntType>::
> _M_waiting(_UniformRandomNumberGenerator& __urng,
> _IntType __t, double __q)
> {
> _IntType __x = 0;
> double __sum = 0.0;
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
> do
> {
> if (__t == __x)
> return __x;
> const double __e = -std::log(1.0 - __aurng());
> __sum += __e / (__t - __x);
> __x += 1;
> }
> while (__sum <= __q);
>
> return __x - 1;
> }
># 1682 "/usr/include/c++/4.8.2/bits/random.tcc" 3
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename binomial_distribution<_IntType>::result_type
> binomial_distribution<_IntType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> result_type __ret;
> const _IntType __t = __param.t();
> const double __p = __param.p();
> const double __p12 = __p <= 0.5 ? __p : 1.0 - __p;
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
>
> if (!__param._M_easy)
> {
> double __x;
>
>
> const double __naf =
> (1 - std::numeric_limits<double>::epsilon()) / 2;
> const double __thr =
> std::numeric_limits<_IntType>::max() + __naf;
>
> const double __np = std::floor(__t * __p12);
>
>
> const double __spi_2 = 1.2533141373155002512078826424055226L;
> const double __a1 = __param._M_a1;
> const double __a12 = __a1 + __param._M_s2 * __spi_2;
> const double __a123 = __param._M_a123;
> const double __s1s = __param._M_s1 * __param._M_s1;
> const double __s2s = __param._M_s2 * __param._M_s2;
>
> bool __reject;
> do
> {
> const double __u = __param._M_s * __aurng();
>
> double __v;
>
> if (__u <= __a1)
> {
> const double __n = _M_nd(__urng);
> const double __y = __param._M_s1 * std::abs(__n);
> __reject = __y >= __param._M_d1;
> if (!__reject)
> {
> const double __e = -std::log(1.0 - __aurng());
> __x = std::floor(__y);
> __v = -__e - __n * __n / 2 + __param._M_c;
> }
> }
> else if (__u <= __a12)
> {
> const double __n = _M_nd(__urng);
> const double __y = __param._M_s2 * std::abs(__n);
> __reject = __y >= __param._M_d2;
> if (!__reject)
> {
> const double __e = -std::log(1.0 - __aurng());
> __x = std::floor(-__y);
> __v = -__e - __n * __n / 2;
> }
> }
> else if (__u <= __a123)
> {
> const double __e1 = -std::log(1.0 - __aurng());
> const double __e2 = -std::log(1.0 - __aurng());
>
> const double __y = __param._M_d1
> + 2 * __s1s * __e1 / __param._M_d1;
> __x = std::floor(__y);
> __v = (-__e2 + __param._M_d1 * (1 / (__t - __np)
> -__y / (2 * __s1s)));
> __reject = false;
> }
> else
> {
> const double __e1 = -std::log(1.0 - __aurng());
> const double __e2 = -std::log(1.0 - __aurng());
>
> const double __y = __param._M_d2
> + 2 * __s2s * __e1 / __param._M_d2;
> __x = std::floor(-__y);
> __v = -__e2 - __param._M_d2 * __y / (2 * __s2s);
> __reject = false;
> }
>
> __reject = __reject || __x < -__np || __x > __t - __np;
> if (!__reject)
> {
> const double __lfx =
> std::lgamma(__np + __x + 1)
> + std::lgamma(__t - (__np + __x) + 1);
> __reject = __v > __param._M_lf - __lfx
> + __x * __param._M_lp1p;
> }
>
> __reject |= __x + __np >= __thr;
> }
> while (__reject);
>
> __x += __np + __naf;
>
> const _IntType __z = _M_waiting(__urng, __t - _IntType(__x),
> __param._M_q);
> __ret = _IntType(__x) + __z;
> }
> else
>
> __ret = _M_waiting(__urng, __t, __param._M_q);
>
> if (__p12 != __p)
> __ret = __t - __ret;
> return __ret;
> }
>
> template<typename _IntType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> binomial_distribution<_IntType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
>
>
> while (__f != __t)
> *__f++ = this->operator()(__urng, __param);
> }
>
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const binomial_distribution<_IntType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<double>::max_digits10);
>
> __os << __x.t() << __space << __x.p()
> << __space << __x._M_nd;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> binomial_distribution<_IntType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _IntType __t;
> double __p;
> __is >> __t >> __p >> __x._M_nd;
> __x.param(typename binomial_distribution<_IntType>::
> param_type(__t, __p));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> std::exponential_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
>
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
> while (__f != __t)
> *__f++ = -std::log(result_type(1) - __aurng()) / __p.lambda();
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const exponential_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__os.widen(' '));
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.lambda();
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> exponential_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __lambda;
> __is >> __lambda;
> __x.param(typename exponential_distribution<_RealType>::
> param_type(__lambda));
>
> __is.flags(__flags);
> return __is;
> }
># 1931 "/usr/include/c++/4.8.2/bits/random.tcc" 3
> template<typename _RealType>
> template<typename _UniformRandomNumberGenerator>
> typename normal_distribution<_RealType>::result_type
> normal_distribution<_RealType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> result_type __ret;
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
>
> if (_M_saved_available)
> {
> _M_saved_available = false;
> __ret = _M_saved;
> }
> else
> {
> result_type __x, __y, __r2;
> do
> {
> __x = result_type(2.0) * __aurng() - 1.0;
> __y = result_type(2.0) * __aurng() - 1.0;
> __r2 = __x * __x + __y * __y;
> }
> while (__r2 > 1.0 || __r2 == 0.0);
>
> const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
> _M_saved = __x * __mult;
> _M_saved_available = true;
> __ret = __y * __mult;
> }
>
> __ret = __ret * __param.stddev() + __param.mean();
> return __ret;
> }
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> normal_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
>
>
> if (__f == __t)
> return;
>
> if (_M_saved_available)
> {
> _M_saved_available = false;
> *__f++ = _M_saved * __param.stddev() + __param.mean();
>
> if (__f == __t)
> return;
> }
>
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
>
> while (__f + 1 < __t)
> {
> result_type __x, __y, __r2;
> do
> {
> __x = result_type(2.0) * __aurng() - 1.0;
> __y = result_type(2.0) * __aurng() - 1.0;
> __r2 = __x * __x + __y * __y;
> }
> while (__r2 > 1.0 || __r2 == 0.0);
>
> const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
> *__f++ = __y * __mult * __param.stddev() + __param.mean();
> *__f++ = __x * __mult * __param.stddev() + __param.mean();
> }
>
> if (__f != __t)
> {
> result_type __x, __y, __r2;
> do
> {
> __x = result_type(2.0) * __aurng() - 1.0;
> __y = result_type(2.0) * __aurng() - 1.0;
> __r2 = __x * __x + __y * __y;
> }
> while (__r2 > 1.0 || __r2 == 0.0);
>
> const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
> _M_saved = __x * __mult;
> _M_saved_available = true;
> *__f = __y * __mult * __param.stddev() + __param.mean();
> }
> }
>
> template<typename _RealType>
> bool
> operator==(const std::normal_distribution<_RealType>& __d1,
> const std::normal_distribution<_RealType>& __d2)
> {
> if (__d1._M_param == __d2._M_param
> && __d1._M_saved_available == __d2._M_saved_available)
> {
> if (__d1._M_saved_available
> && __d1._M_saved == __d2._M_saved)
> return true;
> else if(!__d1._M_saved_available)
> return true;
> else
> return false;
> }
> else
> return false;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const normal_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.mean() << __space << __x.stddev()
> << __space << __x._M_saved_available;
> if (__x._M_saved_available)
> __os << __space << __x._M_saved;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> normal_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> double __mean, __stddev;
> __is >> __mean >> __stddev
> >> __x._M_saved_available;
> if (__x._M_saved_available)
> __is >> __x._M_saved;
> __x.param(typename normal_distribution<_RealType>::
> param_type(__mean, __stddev));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> lognormal_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
>
> while (__f != __t)
> *__f++ = std::exp(__p.s() * _M_nd(__urng) + __p.m());
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const lognormal_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.m() << __space << __x.s()
> << __space << __x._M_nd;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> lognormal_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __m, __s;
> __is >> __m >> __s >> __x._M_nd;
> __x.param(typename lognormal_distribution<_RealType>::
> param_type(__m, __s));
>
> __is.flags(__flags);
> return __is;
> }
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> std::chi_squared_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> {
>
> while (__f != __t)
> *__f++ = 2 * _M_gd(__urng);
> }
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> std::chi_squared_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const typename
> std::gamma_distribution<result_type>::param_type& __p)
> {
>
> while (__f != __t)
> *__f++ = 2 * _M_gd(__urng, __p);
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const chi_squared_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.n() << __space << __x._M_gd;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> chi_squared_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __n;
> __is >> __n >> __x._M_gd;
> __x.param(typename chi_squared_distribution<_RealType>::
> param_type(__n));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> template<typename _UniformRandomNumberGenerator>
> typename cauchy_distribution<_RealType>::result_type
> cauchy_distribution<_RealType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
> _RealType __u;
> do
> __u = __aurng();
> while (__u == 0.5);
>
> const _RealType __pi = 3.1415926535897932384626433832795029L;
> return __p.a() + __p.b() * std::tan(__pi * __u);
> }
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> cauchy_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
>
> const _RealType __pi = 3.1415926535897932384626433832795029L;
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
> while (__f != __t)
> {
> _RealType __u;
> do
> __u = __aurng();
> while (__u == 0.5);
>
> *__f++ = __p.a() + __p.b() * std::tan(__pi * __u);
> }
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const cauchy_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.a() << __space << __x.b();
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> cauchy_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __a, __b;
> __is >> __a >> __b;
> __x.param(typename cauchy_distribution<_RealType>::
> param_type(__a, __b));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> std::fisher_f_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> {
>
> while (__f != __t)
> *__f++ = ((_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()));
> }
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> std::fisher_f_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
>
> typedef typename std::gamma_distribution<result_type>::param_type
> param_type;
> param_type __p1(__p.m() / 2);
> param_type __p2(__p.n() / 2);
> while (__f != __t)
> *__f++ = ((_M_gd_x(__urng, __p1) * n())
> / (_M_gd_y(__urng, __p2) * m()));
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const fisher_f_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.m() << __space << __x.n()
> << __space << __x._M_gd_x << __space << __x._M_gd_y;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> fisher_f_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __m, __n;
> __is >> __m >> __n >> __x._M_gd_x >> __x._M_gd_y;
> __x.param(typename fisher_f_distribution<_RealType>::
> param_type(__m, __n));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> std::student_t_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> {
>
> while (__f != __t)
> *__f++ = _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng));
> }
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> std::student_t_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
>
> typename std::gamma_distribution<result_type>::param_type
> __p2(__p.n() / 2, 2);
> while (__f != __t)
> *__f++ = _M_nd(__urng) * std::sqrt(__p.n() / _M_gd(__urng, __p2));
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const student_t_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.n() << __space << __x._M_nd << __space << __x._M_gd;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> student_t_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __n;
> __is >> __n >> __x._M_nd >> __x._M_gd;
> __x.param(typename student_t_distribution<_RealType>::param_type(__n));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> void
> gamma_distribution<_RealType>::param_type::
> _M_initialize()
> {
> _M_malpha = _M_alpha < 1.0 ? _M_alpha + _RealType(1.0) : _M_alpha;
>
> const _RealType __a1 = _M_malpha - _RealType(1.0) / _RealType(3.0);
> _M_a2 = _RealType(1.0) / std::sqrt(_RealType(9.0) * __a1);
> }
>
>
>
>
>
>
> template<typename _RealType>
> template<typename _UniformRandomNumberGenerator>
> typename gamma_distribution<_RealType>::result_type
> gamma_distribution<_RealType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
>
> result_type __u, __v, __n;
> const result_type __a1 = (__param._M_malpha
> - _RealType(1.0) / _RealType(3.0));
>
> do
> {
> do
> {
> __n = _M_nd(__urng);
> __v = result_type(1.0) + __param._M_a2 * __n;
> }
> while (__v <= 0.0);
>
> __v = __v * __v * __v;
> __u = __aurng();
> }
> while (__u > result_type(1.0) - 0.331 * __n * __n * __n * __n
> && (std::log(__u) > (0.5 * __n * __n + __a1
> * (1.0 - __v + std::log(__v)))));
>
> if (__param.alpha() == __param._M_malpha)
> return __a1 * __v * __param.beta();
> else
> {
> do
> __u = __aurng();
> while (__u == 0.0);
>
> return (std::pow(__u, result_type(1.0) / __param.alpha())
> * __a1 * __v * __param.beta());
> }
> }
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> gamma_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
>
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
>
> result_type __u, __v, __n;
> const result_type __a1 = (__param._M_malpha
> - _RealType(1.0) / _RealType(3.0));
>
> if (__param.alpha() == __param._M_malpha)
> while (__f != __t)
> {
> do
> {
> do
> {
> __n = _M_nd(__urng);
> __v = result_type(1.0) + __param._M_a2 * __n;
> }
> while (__v <= 0.0);
>
> __v = __v * __v * __v;
> __u = __aurng();
> }
> while (__u > result_type(1.0) - 0.331 * __n * __n * __n * __n
> && (std::log(__u) > (0.5 * __n * __n + __a1
> * (1.0 - __v + std::log(__v)))));
>
> *__f++ = __a1 * __v * __param.beta();
> }
> else
> while (__f != __t)
> {
> do
> {
> do
> {
> __n = _M_nd(__urng);
> __v = result_type(1.0) + __param._M_a2 * __n;
> }
> while (__v <= 0.0);
>
> __v = __v * __v * __v;
> __u = __aurng();
> }
> while (__u > result_type(1.0) - 0.331 * __n * __n * __n * __n
> && (std::log(__u) > (0.5 * __n * __n + __a1
> * (1.0 - __v + std::log(__v)))));
>
> do
> __u = __aurng();
> while (__u == 0.0);
>
> *__f++ = (std::pow(__u, result_type(1.0) / __param.alpha())
> * __a1 * __v * __param.beta());
> }
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const gamma_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.alpha() << __space << __x.beta()
> << __space << __x._M_nd;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> gamma_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __alpha_val, __beta_val;
> __is >> __alpha_val >> __beta_val >> __x._M_nd;
> __x.param(typename gamma_distribution<_RealType>::
> param_type(__alpha_val, __beta_val));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> template<typename _UniformRandomNumberGenerator>
> typename weibull_distribution<_RealType>::result_type
> weibull_distribution<_RealType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
> return __p.b() * std::pow(-std::log(result_type(1) - __aurng()),
> result_type(1) / __p.a());
> }
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> weibull_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
>
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
> auto __inv_a = result_type(1) / __p.a();
>
> while (__f != __t)
> *__f++ = __p.b() * std::pow(-std::log(result_type(1) - __aurng()),
> __inv_a);
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const weibull_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.a() << __space << __x.b();
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> weibull_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __a, __b;
> __is >> __a >> __b;
> __x.param(typename weibull_distribution<_RealType>::
> param_type(__a, __b));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> template<typename _UniformRandomNumberGenerator>
> typename extreme_value_distribution<_RealType>::result_type
> extreme_value_distribution<_RealType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
> return __p.a() - __p.b() * std::log(-std::log(result_type(1)
> - __aurng()));
> }
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> extreme_value_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
>
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
>
> while (__f != __t)
> *__f++ = __p.a() - __p.b() * std::log(-std::log(result_type(1)
> - __aurng()));
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const extreme_value_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.a() << __space << __x.b();
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> extreme_value_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __a, __b;
> __is >> __a >> __b;
> __x.param(typename extreme_value_distribution<_RealType>::
> param_type(__a, __b));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _IntType>
> void
> discrete_distribution<_IntType>::param_type::
> _M_initialize()
> {
> if (_M_prob.size() < 2)
> {
> _M_prob.clear();
> return;
> }
>
> const double __sum = std::accumulate(_M_prob.begin(),
> _M_prob.end(), 0.0);
>
> __detail::__normalize(_M_prob.begin(), _M_prob.end(), _M_prob.begin(),
> __sum);
>
> _M_cp.reserve(_M_prob.size());
> std::partial_sum(_M_prob.begin(), _M_prob.end(),
> std::back_inserter(_M_cp));
>
> _M_cp[_M_cp.size() - 1] = 1.0;
> }
>
> template<typename _IntType>
> template<typename _Func>
> discrete_distribution<_IntType>::param_type::
> param_type(size_t __nw, double __xmin, double __xmax, _Func __fw)
> : _M_prob(), _M_cp()
> {
> const size_t __n = __nw == 0 ? 1 : __nw;
> const double __delta = (__xmax - __xmin) / __n;
>
> _M_prob.reserve(__n);
> for (size_t __k = 0; __k < __nw; ++__k)
> _M_prob.push_back(__fw(__xmin + __k * __delta + 0.5 * __delta));
>
> _M_initialize();
> }
>
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename discrete_distribution<_IntType>::result_type
> discrete_distribution<_IntType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> if (__param._M_cp.empty())
> return result_type(0);
>
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
> const double __p = __aurng();
> auto __pos = std::lower_bound(__param._M_cp.begin(),
> __param._M_cp.end(), __p);
>
> return __pos - __param._M_cp.begin();
> }
>
> template<typename _IntType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> discrete_distribution<_IntType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
>
>
> if (__param._M_cp.empty())
> {
> while (__f != __t)
> *__f++ = result_type(0);
> return;
> }
>
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
> while (__f != __t)
> {
> const double __p = __aurng();
> auto __pos = std::lower_bound(__param._M_cp.begin(),
> __param._M_cp.end(), __p);
>
> *__f++ = __pos - __param._M_cp.begin();
> }
> }
>
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const discrete_distribution<_IntType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<double>::max_digits10);
>
> std::vector<double> __prob = __x.probabilities();
> __os << __prob.size();
> for (auto __dit = __prob.begin(); __dit != __prob.end(); ++__dit)
> __os << __space << *__dit;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> discrete_distribution<_IntType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> size_t __n;
> __is >> __n;
>
> std::vector<double> __prob_vec;
> __prob_vec.reserve(__n);
> for (; __n != 0; --__n)
> {
> double __prob;
> __is >> __prob;
> __prob_vec.push_back(__prob);
> }
>
> __x.param(typename discrete_distribution<_IntType>::
> param_type(__prob_vec.begin(), __prob_vec.end()));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> void
> piecewise_constant_distribution<_RealType>::param_type::
> _M_initialize()
> {
> if (_M_int.size() < 2
> || (_M_int.size() == 2
> && _M_int[0] == _RealType(0)
> && _M_int[1] == _RealType(1)))
> {
> _M_int.clear();
> _M_den.clear();
> return;
> }
>
> const double __sum = std::accumulate(_M_den.begin(),
> _M_den.end(), 0.0);
>
> __detail::__normalize(_M_den.begin(), _M_den.end(), _M_den.begin(),
> __sum);
>
> _M_cp.reserve(_M_den.size());
> std::partial_sum(_M_den.begin(), _M_den.end(),
> std::back_inserter(_M_cp));
>
>
> _M_cp[_M_cp.size() - 1] = 1.0;
>
> for (size_t __k = 0; __k < _M_den.size(); ++__k)
> _M_den[__k] /= _M_int[__k + 1] - _M_int[__k];
> }
>
> template<typename _RealType>
> template<typename _InputIteratorB, typename _InputIteratorW>
> piecewise_constant_distribution<_RealType>::param_type::
> param_type(_InputIteratorB __bbegin,
> _InputIteratorB __bend,
> _InputIteratorW __wbegin)
> : _M_int(), _M_den(), _M_cp()
> {
> if (__bbegin != __bend)
> {
> for (;;)
> {
> _M_int.push_back(*__bbegin);
> ++__bbegin;
> if (__bbegin == __bend)
> break;
>
> _M_den.push_back(*__wbegin);
> ++__wbegin;
> }
> }
>
> _M_initialize();
> }
>
> template<typename _RealType>
> template<typename _Func>
> piecewise_constant_distribution<_RealType>::param_type::
> param_type(initializer_list<_RealType> __bl, _Func __fw)
> : _M_int(), _M_den(), _M_cp()
> {
> _M_int.reserve(__bl.size());
> for (auto __biter = __bl.begin(); __biter != __bl.end(); ++__biter)
> _M_int.push_back(*__biter);
>
> _M_den.reserve(_M_int.size() - 1);
> for (size_t __k = 0; __k < _M_int.size() - 1; ++__k)
> _M_den.push_back(__fw(0.5 * (_M_int[__k + 1] + _M_int[__k])));
>
> _M_initialize();
> }
>
> template<typename _RealType>
> template<typename _Func>
> piecewise_constant_distribution<_RealType>::param_type::
> param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw)
> : _M_int(), _M_den(), _M_cp()
> {
> const size_t __n = __nw == 0 ? 1 : __nw;
> const _RealType __delta = (__xmax - __xmin) / __n;
>
> _M_int.reserve(__n + 1);
> for (size_t __k = 0; __k <= __nw; ++__k)
> _M_int.push_back(__xmin + __k * __delta);
>
> _M_den.reserve(__n);
> for (size_t __k = 0; __k < __nw; ++__k)
> _M_den.push_back(__fw(_M_int[__k] + 0.5 * __delta));
>
> _M_initialize();
> }
>
> template<typename _RealType>
> template<typename _UniformRandomNumberGenerator>
> typename piecewise_constant_distribution<_RealType>::result_type
> piecewise_constant_distribution<_RealType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
> const double __p = __aurng();
> if (__param._M_cp.empty())
> return __p;
>
> auto __pos = std::lower_bound(__param._M_cp.begin(),
> __param._M_cp.end(), __p);
> const size_t __i = __pos - __param._M_cp.begin();
>
> const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0;
>
> return __param._M_int[__i] + (__p - __pref) / __param._M_den[__i];
> }
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> piecewise_constant_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
>
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
> if (__param._M_cp.empty())
> {
> while (__f != __t)
> *__f++ = __aurng();
> return;
> }
>
> while (__f != __t)
> {
> const double __p = __aurng();
>
> auto __pos = std::lower_bound(__param._M_cp.begin(),
> __param._M_cp.end(), __p);
> const size_t __i = __pos - __param._M_cp.begin();
>
> const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0;
>
> *__f++ = (__param._M_int[__i]
> + (__p - __pref) / __param._M_den[__i]);
> }
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const piecewise_constant_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> std::vector<_RealType> __int = __x.intervals();
> __os << __int.size() - 1;
>
> for (auto __xit = __int.begin(); __xit != __int.end(); ++__xit)
> __os << __space << *__xit;
>
> std::vector<double> __den = __x.densities();
> for (auto __dit = __den.begin(); __dit != __den.end(); ++__dit)
> __os << __space << *__dit;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> piecewise_constant_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> size_t __n;
> __is >> __n;
>
> std::vector<_RealType> __int_vec;
> __int_vec.reserve(__n + 1);
> for (size_t __i = 0; __i <= __n; ++__i)
> {
> _RealType __int;
> __is >> __int;
> __int_vec.push_back(__int);
> }
>
> std::vector<double> __den_vec;
> __den_vec.reserve(__n);
> for (size_t __i = 0; __i < __n; ++__i)
> {
> double __den;
> __is >> __den;
> __den_vec.push_back(__den);
> }
>
> __x.param(typename piecewise_constant_distribution<_RealType>::
> param_type(__int_vec.begin(), __int_vec.end(), __den_vec.begin()));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> void
> piecewise_linear_distribution<_RealType>::param_type::
> _M_initialize()
> {
> if (_M_int.size() < 2
> || (_M_int.size() == 2
> && _M_int[0] == _RealType(0)
> && _M_int[1] == _RealType(1)
> && _M_den[0] == _M_den[1]))
> {
> _M_int.clear();
> _M_den.clear();
> return;
> }
>
> double __sum = 0.0;
> _M_cp.reserve(_M_int.size() - 1);
> _M_m.reserve(_M_int.size() - 1);
> for (size_t __k = 0; __k < _M_int.size() - 1; ++__k)
> {
> const _RealType __delta = _M_int[__k + 1] - _M_int[__k];
> __sum += 0.5 * (_M_den[__k + 1] + _M_den[__k]) * __delta;
> _M_cp.push_back(__sum);
> _M_m.push_back((_M_den[__k + 1] - _M_den[__k]) / __delta);
> }
>
>
> __detail::__normalize(_M_den.begin(), _M_den.end(), _M_den.begin(),
> __sum);
>
> __detail::__normalize(_M_cp.begin(), _M_cp.end(), _M_cp.begin(), __sum);
>
> __detail::__normalize(_M_m.begin(), _M_m.end(), _M_m.begin(), __sum);
>
>
> _M_cp[_M_cp.size() - 1] = 1.0;
> }
>
> template<typename _RealType>
> template<typename _InputIteratorB, typename _InputIteratorW>
> piecewise_linear_distribution<_RealType>::param_type::
> param_type(_InputIteratorB __bbegin,
> _InputIteratorB __bend,
> _InputIteratorW __wbegin)
> : _M_int(), _M_den(), _M_cp(), _M_m()
> {
> for (; __bbegin != __bend; ++__bbegin, ++__wbegin)
> {
> _M_int.push_back(*__bbegin);
> _M_den.push_back(*__wbegin);
> }
>
> _M_initialize();
> }
>
> template<typename _RealType>
> template<typename _Func>
> piecewise_linear_distribution<_RealType>::param_type::
> param_type(initializer_list<_RealType> __bl, _Func __fw)
> : _M_int(), _M_den(), _M_cp(), _M_m()
> {
> _M_int.reserve(__bl.size());
> _M_den.reserve(__bl.size());
> for (auto __biter = __bl.begin(); __biter != __bl.end(); ++__biter)
> {
> _M_int.push_back(*__biter);
> _M_den.push_back(__fw(*__biter));
> }
>
> _M_initialize();
> }
>
> template<typename _RealType>
> template<typename _Func>
> piecewise_linear_distribution<_RealType>::param_type::
> param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw)
> : _M_int(), _M_den(), _M_cp(), _M_m()
> {
> const size_t __n = __nw == 0 ? 1 : __nw;
> const _RealType __delta = (__xmax - __xmin) / __n;
>
> _M_int.reserve(__n + 1);
> _M_den.reserve(__n + 1);
> for (size_t __k = 0; __k <= __nw; ++__k)
> {
> _M_int.push_back(__xmin + __k * __delta);
> _M_den.push_back(__fw(_M_int[__k] + __delta));
> }
>
> _M_initialize();
> }
>
> template<typename _RealType>
> template<typename _UniformRandomNumberGenerator>
> typename piecewise_linear_distribution<_RealType>::result_type
> piecewise_linear_distribution<_RealType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
> const double __p = __aurng();
> if (__param._M_cp.empty())
> return __p;
>
> auto __pos = std::lower_bound(__param._M_cp.begin(),
> __param._M_cp.end(), __p);
> const size_t __i = __pos - __param._M_cp.begin();
>
> const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0;
>
> const double __a = 0.5 * __param._M_m[__i];
> const double __b = __param._M_den[__i];
> const double __cm = __p - __pref;
>
> _RealType __x = __param._M_int[__i];
> if (__a == 0)
> __x += __cm / __b;
> else
> {
> const double __d = __b * __b + 4.0 * __a * __cm;
> __x += 0.5 * (std::sqrt(__d) - __b) / __a;
> }
>
> return __x;
> }
>
> template<typename _RealType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> piecewise_linear_distribution<_RealType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
>
>
> while (__f != __t)
> *__f++ = this->operator()(__urng, __param);
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const piecewise_linear_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> std::vector<_RealType> __int = __x.intervals();
> __os << __int.size() - 1;
>
> for (auto __xit = __int.begin(); __xit != __int.end(); ++__xit)
> __os << __space << *__xit;
>
> std::vector<double> __den = __x.densities();
> for (auto __dit = __den.begin(); __dit != __den.end(); ++__dit)
> __os << __space << *__dit;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> piecewise_linear_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> size_t __n;
> __is >> __n;
>
> std::vector<_RealType> __int_vec;
> __int_vec.reserve(__n + 1);
> for (size_t __i = 0; __i <= __n; ++__i)
> {
> _RealType __int;
> __is >> __int;
> __int_vec.push_back(__int);
> }
>
> std::vector<double> __den_vec;
> __den_vec.reserve(__n + 1);
> for (size_t __i = 0; __i <= __n; ++__i)
> {
> double __den;
> __is >> __den;
> __den_vec.push_back(__den);
> }
>
> __x.param(typename piecewise_linear_distribution<_RealType>::
> param_type(__int_vec.begin(), __int_vec.end(), __den_vec.begin()));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _IntType>
> seed_seq::seed_seq(std::initializer_list<_IntType> __il)
> {
> for (auto __iter = __il.begin(); __iter != __il.end(); ++__iter)
> _M_v.push_back(__detail::__mod<result_type,
> __detail::_Shift<result_type, 32>::__value>(*__iter));
> }
>
> template<typename _InputIterator>
> seed_seq::seed_seq(_InputIterator __begin, _InputIterator __end)
> {
> for (_InputIterator __iter = __begin; __iter != __end; ++__iter)
> _M_v.push_back(__detail::__mod<result_type,
> __detail::_Shift<result_type, 32>::__value>(*__iter));
> }
>
> template<typename _RandomAccessIterator>
> void
> seed_seq::generate(_RandomAccessIterator __begin,
> _RandomAccessIterator __end)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _Type;
>
> if (__begin == __end)
> return;
>
> std::fill(__begin, __end, _Type(0x8b8b8b8bu));
>
> const size_t __n = __end - __begin;
> const size_t __s = _M_v.size();
> const size_t __t = (__n >= 623) ? 11
> : (__n >= 68) ? 7
> : (__n >= 39) ? 5
> : (__n >= 7) ? 3
> : (__n - 1) / 2;
> const size_t __p = (__n - __t) / 2;
> const size_t __q = __p + __t;
> const size_t __m = std::max(size_t(__s + 1), __n);
>
> for (size_t __k = 0; __k < __m; ++__k)
> {
> _Type __arg = (__begin[__k % __n]
> ^ __begin[(__k + __p) % __n]
> ^ __begin[(__k - 1) % __n]);
> _Type __r1 = __arg ^ (__arg >> 27);
> __r1 = __detail::__mod<_Type,
> __detail::_Shift<_Type, 32>::__value>(1664525u * __r1);
> _Type __r2 = __r1;
> if (__k == 0)
> __r2 += __s;
> else if (__k <= __s)
> __r2 += __k % __n + _M_v[__k - 1];
> else
> __r2 += __k % __n;
> __r2 = __detail::__mod<_Type,
> __detail::_Shift<_Type, 32>::__value>(__r2);
> __begin[(__k + __p) % __n] += __r1;
> __begin[(__k + __q) % __n] += __r2;
> __begin[__k % __n] = __r2;
> }
>
> for (size_t __k = __m; __k < __m + __n; ++__k)
> {
> _Type __arg = (__begin[__k % __n]
> + __begin[(__k + __p) % __n]
> + __begin[(__k - 1) % __n]);
> _Type __r3 = __arg ^ (__arg >> 27);
> __r3 = __detail::__mod<_Type,
> __detail::_Shift<_Type, 32>::__value>(1566083941u * __r3);
> _Type __r4 = __r3 - __k % __n;
> __r4 = __detail::__mod<_Type,
> __detail::_Shift<_Type, 32>::__value>(__r4);
> __begin[(__k + __p) % __n] ^= __r3;
> __begin[(__k + __q) % __n] ^= __r4;
> __begin[__k % __n] = __r4;
> }
> }
>
> template<typename _RealType, size_t __bits,
> typename _UniformRandomNumberGenerator>
> _RealType
> generate_canonical(_UniformRandomNumberGenerator& __urng)
> {
> const size_t __b
> = std::min(static_cast<size_t>(std::numeric_limits<_RealType>::digits),
> __bits);
> const long double __r = static_cast<long double>(__urng.max())
> - static_cast<long double>(__urng.min()) + 1.0L;
> const size_t __log2r = std::log(__r) / std::log(2.0L);
> size_t __k = std::max<size_t>(1UL, (__b + __log2r - 1UL) / __log2r);
> _RealType __sum = _RealType(0);
> _RealType __tmp = _RealType(1);
> for (; __k != 0; --__k)
> {
> __sum += _RealType(__urng() - __urng.min()) * __tmp;
> __tmp *= __r;
> }
> return __sum / __tmp;
> }
>
>
>}
># 53 "/usr/include/c++/4.8.2/random" 2 3
># 66 "/usr/include/c++/4.8.2/bits/stl_algo.h" 2 3
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _Iterator>
> void
> __move_median_to_first(_Iterator __result, _Iterator __a,
> _Iterator __b, _Iterator __c)
> {
>
> 
>
>
> if (*__a < *__b)
> {
> if (*__b < *__c)
> std::iter_swap(__result, __b);
> else if (*__a < *__c)
> std::iter_swap(__result, __c);
> else
> std::iter_swap(__result, __a);
> }
> else if (*__a < *__c)
> std::iter_swap(__result, __a);
> else if (*__b < *__c)
> std::iter_swap(__result, __c);
> else
> std::iter_swap(__result, __b);
> }
>
>
> template<typename _Iterator, typename _Compare>
> void
> __move_median_to_first(_Iterator __result, _Iterator __a,
> _Iterator __b, _Iterator __c,
> _Compare __comp)
> {
>
> 
>
>
>
> if (__comp(*__a, *__b))
> {
> if (__comp(*__b, *__c))
> std::iter_swap(__result, __b);
> else if (__comp(*__a, *__c))
> std::iter_swap(__result, __c);
> else
> std::iter_swap(__result, __a);
> }
> else if (__comp(*__a, *__c))
> std::iter_swap(__result, __a);
> else if (__comp(*__b, *__c))
> std::iter_swap(__result, __c);
> else
> std::iter_swap(__result, __b);
> }
>
>
>
>
> template<typename _InputIterator, typename _Tp>
> inline _InputIterator
> __find(_InputIterator __first, _InputIterator __last,
> const _Tp& __val, input_iterator_tag)
> {
> while (__first != __last && !(*__first == __val))
> ++__first;
> return __first;
> }
>
>
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> __find_if(_InputIterator __first, _InputIterator __last,
> _Predicate __pred, input_iterator_tag)
> {
> while (__first != __last && !bool(__pred(*__first)))
> ++__first;
> return __first;
> }
>
>
> template<typename _RandomAccessIterator, typename _Tp>
> _RandomAccessIterator
> __find(_RandomAccessIterator __first, _RandomAccessIterator __last,
> const _Tp& __val, random_access_iterator_tag)
> {
> typename iterator_traits<_RandomAccessIterator>::difference_type
> __trip_count = (__last - __first) >> 2;
>
> for (; __trip_count > 0; --__trip_count)
> {
> if (*__first == __val)
> return __first;
> ++__first;
>
> if (*__first == __val)
> return __first;
> ++__first;
>
> if (*__first == __val)
> return __first;
> ++__first;
>
> if (*__first == __val)
> return __first;
> ++__first;
> }
>
> switch (__last - __first)
> {
> case 3:
> if (*__first == __val)
> return __first;
> ++__first;
> case 2:
> if (*__first == __val)
> return __first;
> ++__first;
> case 1:
> if (*__first == __val)
> return __first;
> ++__first;
> case 0:
> default:
> return __last;
> }
> }
>
>
> template<typename _RandomAccessIterator, typename _Predicate>
> _RandomAccessIterator
> __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Predicate __pred, random_access_iterator_tag)
> {
> typename iterator_traits<_RandomAccessIterator>::difference_type
> __trip_count = (__last - __first) >> 2;
>
> for (; __trip_count > 0; --__trip_count)
> {
> if (__pred(*__first))
> return __first;
> ++__first;
>
> if (__pred(*__first))
> return __first;
> ++__first;
>
> if (__pred(*__first))
> return __first;
> ++__first;
>
> if (__pred(*__first))
> return __first;
> ++__first;
> }
>
> switch (__last - __first)
> {
> case 3:
> if (__pred(*__first))
> return __first;
> ++__first;
> case 2:
> if (__pred(*__first))
> return __first;
> ++__first;
> case 1:
> if (__pred(*__first))
> return __first;
> ++__first;
> case 0:
> default:
> return __last;
> }
> }
>
>
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> __find_if_not(_InputIterator __first, _InputIterator __last,
> _Predicate __pred, input_iterator_tag)
> {
> while (__first != __last && bool(__pred(*__first)))
> ++__first;
> return __first;
> }
>
>
> template<typename _RandomAccessIterator, typename _Predicate>
> _RandomAccessIterator
> __find_if_not(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Predicate __pred, random_access_iterator_tag)
> {
> typename iterator_traits<_RandomAccessIterator>::difference_type
> __trip_count = (__last - __first) >> 2;
>
> for (; __trip_count > 0; --__trip_count)
> {
> if (!bool(__pred(*__first)))
> return __first;
> ++__first;
>
> if (!bool(__pred(*__first)))
> return __first;
> ++__first;
>
> if (!bool(__pred(*__first)))
> return __first;
> ++__first;
>
> if (!bool(__pred(*__first)))
> return __first;
> ++__first;
> }
>
> switch (__last - __first)
> {
> case 3:
> if (!bool(__pred(*__first)))
> return __first;
> ++__first;
> case 2:
> if (!bool(__pred(*__first)))
> return __first;
> ++__first;
> case 1:
> if (!bool(__pred(*__first)))
> return __first;
> ++__first;
> case 0:
> default:
> return __last;
> }
> }
>
>
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> __find_if_not(_InputIterator __first, _InputIterator __last,
> _Predicate __pred)
> {
> return std::__find_if_not(__first, __last, __pred,
> std::__iterator_category(__first));
> }
>
>
>
>
> template<typename _InputIterator, typename _Predicate, typename _Distance>
> _InputIterator
> __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
> {
> for (; __len; --__len, ++__first)
> if (!bool(__pred(*__first)))
> break;
> return __first;
> }
># 351 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp>
> _ForwardIterator
> __search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val,
> std::forward_iterator_tag)
> {
> __first = std::find(__first, __last, __val);
> while (__first != __last)
> {
> typename iterator_traits<_ForwardIterator>::difference_type
> __n = __count;
> _ForwardIterator __i = __first;
> ++__i;
> while (__i != __last && __n != 1 && *__i == __val)
> {
> ++__i;
> --__n;
> }
> if (__n == 1)
> return __first;
> if (__i == __last)
> return __last;
> __first = std::find(++__i, __last, __val);
> }
> return __last;
> }
>
>
>
>
>
>
> template<typename _RandomAccessIter, typename _Integer, typename _Tp>
> _RandomAccessIter
> __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
> _Integer __count, const _Tp& __val,
> std::random_access_iterator_tag)
> {
>
> typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
> _DistanceType;
>
> _DistanceType __tailSize = __last - __first;
> _DistanceType __remainder = __count;
>
> while (__remainder <= __tailSize)
> {
> __first += __remainder;
> __tailSize -= __remainder;
>
>
> _RandomAccessIter __backTrack = __first;
> while (*--__backTrack == __val)
> {
> if (--__remainder == 0)
> return (__first - __count);
> }
> __remainder = __count + 1 - (__first - __backTrack);
> }
> return __last;
> }
># 421 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp,
> typename _BinaryPredicate>
> _ForwardIterator
> __search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val,
> _BinaryPredicate __binary_pred, std::forward_iterator_tag)
> {
> while (__first != __last && !bool(__binary_pred(*__first, __val)))
> ++__first;
>
> while (__first != __last)
> {
> typename iterator_traits<_ForwardIterator>::difference_type
> __n = __count;
> _ForwardIterator __i = __first;
> ++__i;
> while (__i != __last && __n != 1 && bool(__binary_pred(*__i, __val)))
> {
> ++__i;
> --__n;
> }
> if (__n == 1)
> return __first;
> if (__i == __last)
> return __last;
> __first = ++__i;
> while (__first != __last
> && !bool(__binary_pred(*__first, __val)))
> ++__first;
> }
> return __last;
> }
>
>
>
>
>
>
>
> template<typename _RandomAccessIter, typename _Integer, typename _Tp,
> typename _BinaryPredicate>
> _RandomAccessIter
> __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
> _Integer __count, const _Tp& __val,
> _BinaryPredicate __binary_pred, std::random_access_iterator_tag)
> {
>
> typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
> _DistanceType;
>
> _DistanceType __tailSize = __last - __first;
> _DistanceType __remainder = __count;
>
> while (__remainder <= __tailSize)
> {
> __first += __remainder;
> __tailSize -= __remainder;
>
>
> _RandomAccessIter __backTrack = __first;
> while (__binary_pred(*--__backTrack, __val))
> {
> if (--__remainder == 0)
> return (__first - __count);
> }
> __remainder = __count + 1 - (__first - __backTrack);
> }
> return __last;
> }
>
>
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> _ForwardIterator1
> __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> forward_iterator_tag, forward_iterator_tag)
> {
> if (__first2 == __last2)
> return __last1;
> else
> {
> _ForwardIterator1 __result = __last1;
> while (1)
> {
> _ForwardIterator1 __new_result
> = std::search(__first1, __last1, __first2, __last2);
> if (__new_result == __last1)
> return __result;
> else
> {
> __result = __new_result;
> __first1 = __new_result;
> ++__first1;
> }
> }
> }
> }
>
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> _ForwardIterator1
> __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> forward_iterator_tag, forward_iterator_tag,
> _BinaryPredicate __comp)
> {
> if (__first2 == __last2)
> return __last1;
> else
> {
> _ForwardIterator1 __result = __last1;
> while (1)
> {
> _ForwardIterator1 __new_result
> = std::search(__first1, __last1, __first2,
> __last2, __comp);
> if (__new_result == __last1)
> return __result;
> else
> {
> __result = __new_result;
> __first1 = __new_result;
> ++__first1;
> }
> }
> }
> }
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
> _BidirectionalIterator1
> __find_end(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> bidirectional_iterator_tag, bidirectional_iterator_tag)
> {
>
> 
>
> 
>
>
> typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
> typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
>
> _RevIterator1 __rlast1(__first1);
> _RevIterator2 __rlast2(__first2);
> _RevIterator1 __rresult = std::search(_RevIterator1(__last1),
> __rlast1,
> _RevIterator2(__last2),
> __rlast2);
>
> if (__rresult == __rlast1)
> return __last1;
> else
> {
> _BidirectionalIterator1 __result = __rresult.base();
> std::advance(__result, -std::distance(__first2, __last2));
> return __result;
> }
> }
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _BinaryPredicate>
> _BidirectionalIterator1
> __find_end(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> bidirectional_iterator_tag, bidirectional_iterator_tag,
> _BinaryPredicate __comp)
> {
>
> 
>
> 
>
>
> typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
> typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
>
> _RevIterator1 __rlast1(__first1);
> _RevIterator2 __rlast2(__first2);
> _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
> _RevIterator2(__last2), __rlast2,
> __comp);
>
> if (__rresult == __rlast1)
> return __last1;
> else
> {
> _BidirectionalIterator1 __result = __rresult.base();
> std::advance(__result, -std::distance(__first2, __last2));
> return __result;
> }
> }
># 645 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> inline _ForwardIterator1
> find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> return std::__find_end(__first1, __last1, __first2, __last2,
> std::__iterator_category(__first1),
> std::__iterator_category(__first2));
> }
># 692 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> inline _ForwardIterator1
> find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> _BinaryPredicate __comp)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> return std::__find_end(__first1, __last1, __first2, __last2,
> std::__iterator_category(__first1),
> std::__iterator_category(__first2),
> __comp);
> }
># 727 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline bool
> all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
> { return __last == std::find_if_not(__first, __last, __pred); }
># 744 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline bool
> none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
> { return __last == std::find_if(__first, __last, __pred); }
># 762 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline bool
> any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
> { return !std::none_of(__first, __last, __pred); }
># 777 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> find_if_not(_InputIterator __first, _InputIterator __last,
> _Predicate __pred)
> {
>
> 
> 
>
> ;
> return std::__find_if_not(__first, __last, __pred);
> }
># 800 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline bool
> is_partitioned(_InputIterator __first, _InputIterator __last,
> _Predicate __pred)
> {
> __first = std::find_if_not(__first, __last, __pred);
> return std::none_of(__first, __last, __pred);
> }
># 818 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> partition_point(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
> 
>
>
>
> ;
>
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
> _DistanceType __len = std::distance(__first, __last);
> _DistanceType __half;
> _ForwardIterator __middle;
>
> while (__len > 0)
> {
> __half = __len >> 1;
> __middle = __first;
> std::advance(__middle, __half);
> if (__pred(*__middle))
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else
> __len = __half;
> }
> return __first;
> }
># 871 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator, typename _Tp>
> _OutputIterator
> remove_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, const _Tp& __value)
> {
>
> 
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> if (!(*__first == __value))
> {
> *__result = *__first;
> ++__result;
> }
> return __result;
> }
># 908 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _Predicate>
> _OutputIterator
> remove_copy_if(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _Predicate __pred)
> {
>
> 
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> if (!bool(__pred(*__first)))
> {
> *__result = *__first;
> ++__result;
> }
> return __result;
> }
># 947 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _Predicate>
> _OutputIterator
> copy_if(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _Predicate __pred)
> {
>
> 
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> if (__pred(*__first))
> {
> *__result = *__first;
> ++__result;
> }
> return __result;
> }
>
>
> template<typename _InputIterator, typename _Size, typename _OutputIterator>
> _OutputIterator
> __copy_n(_InputIterator __first, _Size __n,
> _OutputIterator __result, input_iterator_tag)
> {
> if (__n > 0)
> {
> while (true)
> {
> *__result = *__first;
> ++__result;
> if (--__n > 0)
> ++__first;
> else
> break;
> }
> }
> return __result;
> }
>
> template<typename _RandomAccessIterator, typename _Size,
> typename _OutputIterator>
> inline _OutputIterator
> __copy_n(_RandomAccessIterator __first, _Size __n,
> _OutputIterator __result, random_access_iterator_tag)
> { return std::copy(__first, __first + __n, __result); }
># 1011 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Size, typename _OutputIterator>
> inline _OutputIterator
> copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
> {
>
> 
> 
>
>
> return std::__copy_n(__first, __n, __result,
> std::__iterator_category(__first));
> }
># 1039 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator1,
> typename _OutputIterator2, typename _Predicate>
> pair<_OutputIterator1, _OutputIterator2>
> partition_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator1 __out_true, _OutputIterator2 __out_false,
> _Predicate __pred)
> {
>
> 
> 
>
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> if (__pred(*__first))
> {
> *__out_true = *__first;
> ++__out_true;
> }
> else
> {
> *__out_false = *__first;
> ++__out_false;
> }
>
> return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
> }
># 1089 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> _ForwardIterator
> remove(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __value)
> {
>
> 
>
> 
>
> ;
>
> __first = std::find(__first, __last, __value);
> if(__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> ++__first;
> for(; __first != __last; ++__first)
> if(!(*__first == __value))
> {
> *__result = std::move(*__first);
> ++__result;
> }
> return __result;
> }
># 1132 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> remove_if(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
>
> 
>
> ;
>
> __first = std::find_if(__first, __last, __pred);
> if(__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> ++__first;
> for(; __first != __last; ++__first)
> if(!bool(__pred(*__first)))
> {
> *__result = std::move(*__first);
> ++__result;
> }
> return __result;
> }
># 1172 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> unique(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
>
> 
>
> ;
>
>
> __first = std::adjacent_find(__first, __last);
> if (__first == __last)
> return __last;
>
>
> _ForwardIterator __dest = __first;
> ++__first;
> while (++__first != __last)
> if (!(*__dest == *__first))
> *++__dest = std::move(*__first);
> return ++__dest;
> }
># 1212 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _BinaryPredicate>
> _ForwardIterator
> unique(_ForwardIterator __first, _ForwardIterator __last,
> _BinaryPredicate __binary_pred)
> {
>
> 
>
> 
>
>
> ;
>
>
> __first = std::adjacent_find(__first, __last, __binary_pred);
> if (__first == __last)
> return __last;
>
>
> _ForwardIterator __dest = __first;
> ++__first;
> while (++__first != __last)
> if (!bool(__binary_pred(*__dest, *__first)))
> *++__dest = std::move(*__first);
> return ++__dest;
> }
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _OutputIterator>
> _OutputIterator
> __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
> _OutputIterator __result,
> forward_iterator_tag, output_iterator_tag)
> {
>
> _ForwardIterator __next = __first;
> *__result = *__first;
> while (++__next != __last)
> if (!(*__first == *__next))
> {
> __first = __next;
> *++__result = *__first;
> }
> return ++__result;
> }
>
>
>
>
>
>
> template<typename _InputIterator, typename _OutputIterator>
> _OutputIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> input_iterator_tag, output_iterator_tag)
> {
>
> typename iterator_traits<_InputIterator>::value_type __value = *__first;
> *__result = __value;
> while (++__first != __last)
> if (!(__value == *__first))
> {
> __value = *__first;
> *++__result = __value;
> }
> return ++__result;
> }
>
>
>
>
>
>
> template<typename _InputIterator, typename _ForwardIterator>
> _ForwardIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result,
> input_iterator_tag, forward_iterator_tag)
> {
>
> *__result = *__first;
> while (++__first != __last)
> if (!(*__result == *__first))
> *++__result = *__first;
> return ++__result;
> }
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _OutputIterator,
> typename _BinaryPredicate>
> _OutputIterator
> __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
> _OutputIterator __result, _BinaryPredicate __binary_pred,
> forward_iterator_tag, output_iterator_tag)
> {
>
> 
>
>
>
> _ForwardIterator __next = __first;
> *__result = *__first;
> while (++__next != __last)
> if (!bool(__binary_pred(*__first, *__next)))
> {
> __first = __next;
> *++__result = *__first;
> }
> return ++__result;
> }
>
>
>
>
>
>
>
> template<typename _InputIterator, typename _OutputIterator,
> typename _BinaryPredicate>
> _OutputIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _BinaryPredicate __binary_pred,
> input_iterator_tag, output_iterator_tag)
> {
>
> 
>
>
>
> typename iterator_traits<_InputIterator>::value_type __value = *__first;
> *__result = __value;
> while (++__first != __last)
> if (!bool(__binary_pred(__value, *__first)))
> {
> __value = *__first;
> *++__result = __value;
> }
> return ++__result;
> }
>
>
>
>
>
>
>
> template<typename _InputIterator, typename _ForwardIterator,
> typename _BinaryPredicate>
> _ForwardIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result, _BinaryPredicate __binary_pred,
> input_iterator_tag, forward_iterator_tag)
> {
>
> 
>
>
>
> *__result = *__first;
> while (++__first != __last)
> if (!bool(__binary_pred(*__result, *__first)))
> *++__result = *__first;
> return ++__result;
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator>
> void
> __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
> bidirectional_iterator_tag)
> {
> while (true)
> if (__first == __last || __first == --__last)
> return;
> else
> {
> std::iter_swap(__first, __last);
> ++__first;
> }
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator>
> void
> __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
> random_access_iterator_tag)
> {
> if (__first == __last)
> return;
> --__last;
> while (__first < __last)
> {
> std::iter_swap(__first, __last);
> ++__first;
> --__last;
> }
> }
># 1440 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> inline void
> reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
> {
>
> 
>
> ;
> std::__reverse(__first, __last, std::__iterator_category(__first));
> }
># 1467 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _OutputIterator>
> _OutputIterator
> reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
> _OutputIterator __result)
> {
>
> 
>
> 
>
> ;
>
> while (__first != __last)
> {
> --__last;
> *__result = *__last;
> ++__result;
> }
> return __result;
> }
>
>
>
>
>
> template<typename _EuclideanRingElement>
> _EuclideanRingElement
> __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
> {
> while (__n != 0)
> {
> _EuclideanRingElement __t = __m % __n;
> __m = __n;
> __n = __t;
> }
> return __m;
> }
>
>
> template<typename _ForwardIterator>
> void
> __rotate(_ForwardIterator __first,
> _ForwardIterator __middle,
> _ForwardIterator __last,
> forward_iterator_tag)
> {
> if (__first == __middle || __last == __middle)
> return;
>
> _ForwardIterator __first2 = __middle;
> do
> {
> std::iter_swap(__first, __first2);
> ++__first;
> ++__first2;
> if (__first == __middle)
> __middle = __first2;
> }
> while (__first2 != __last);
>
> __first2 = __middle;
>
> while (__first2 != __last)
> {
> std::iter_swap(__first, __first2);
> ++__first;
> ++__first2;
> if (__first == __middle)
> __middle = __first2;
> else if (__first2 == __last)
> __first2 = __middle;
> }
> }
>
>
> template<typename _BidirectionalIterator>
> void
> __rotate(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> bidirectional_iterator_tag)
> {
>
> 
>
>
> if (__first == __middle || __last == __middle)
> return;
>
> std::__reverse(__first, __middle, bidirectional_iterator_tag());
> std::__reverse(__middle, __last, bidirectional_iterator_tag());
>
> while (__first != __middle && __middle != __last)
> {
> std::iter_swap(__first, --__last);
> ++__first;
> }
>
> if (__first == __middle)
> std::__reverse(__middle, __last, bidirectional_iterator_tag());
> else
> std::__reverse(__first, __middle, bidirectional_iterator_tag());
> }
>
>
> template<typename _RandomAccessIterator>
> void
> __rotate(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last,
> random_access_iterator_tag)
> {
>
> 
>
>
> if (__first == __middle || __last == __middle)
> return;
>
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> _Distance __n = __last - __first;
> _Distance __k = __middle - __first;
>
> if (__k == __n - __k)
> {
> std::swap_ranges(__first, __middle, __middle);
> return;
> }
>
> _RandomAccessIterator __p = __first;
>
> for (;;)
> {
> if (__k < __n - __k)
> {
> if (__is_pod(_ValueType) && __k == 1)
> {
> _ValueType __t = std::move(*__p);
> std::move(__p + 1, __p + __n, __p);
> *(__p + __n - 1) = std::move(__t);
> return;
> }
> _RandomAccessIterator __q = __p + __k;
> for (_Distance __i = 0; __i < __n - __k; ++ __i)
> {
> std::iter_swap(__p, __q);
> ++__p;
> ++__q;
> }
> __n %= __k;
> if (__n == 0)
> return;
> std::swap(__n, __k);
> __k = __n - __k;
> }
> else
> {
> __k = __n - __k;
> if (__is_pod(_ValueType) && __k == 1)
> {
> _ValueType __t = std::move(*(__p + __n - 1));
> std::move_backward(__p, __p + __n - 1, __p + __n);
> *__p = std::move(__t);
> return;
> }
> _RandomAccessIterator __q = __p + __n;
> __p = __q - __k;
> for (_Distance __i = 0; __i < __n - __k; ++ __i)
> {
> --__p;
> --__q;
> std::iter_swap(__p, __q);
> }
> __n %= __k;
> if (__n == 0)
> return;
> std::swap(__n, __k);
> }
> }
> }
># 1673 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> inline void
> rotate(_ForwardIterator __first, _ForwardIterator __middle,
> _ForwardIterator __last)
> {
>
> 
>
> ;
> ;
>
> typedef typename iterator_traits<_ForwardIterator>::iterator_category
> _IterType;
> std::__rotate(__first, __middle, __last, _IterType());
> }
># 1709 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _OutputIterator>
> _OutputIterator
> rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
> _ForwardIterator __last, _OutputIterator __result)
> {
>
> 
> 
>
> ;
> ;
>
> return std::copy(__first, __middle,
> std::copy(__middle, __last, __result));
> }
>
>
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> __partition(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred, forward_iterator_tag)
> {
> if (__first == __last)
> return __first;
>
> while (__pred(*__first))
> if (++__first == __last)
> return __first;
>
> _ForwardIterator __next = __first;
>
> while (++__next != __last)
> if (__pred(*__next))
> {
> std::iter_swap(__first, __next);
> ++__first;
> }
>
> return __first;
> }
>
>
> template<typename _BidirectionalIterator, typename _Predicate>
> _BidirectionalIterator
> __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
> _Predicate __pred, bidirectional_iterator_tag)
> {
> while (true)
> {
> while (true)
> if (__first == __last)
> return __first;
> else if (__pred(*__first))
> ++__first;
> else
> break;
> --__last;
> while (true)
> if (__first == __last)
> return __first;
> else if (!bool(__pred(*__last)))
> --__last;
> else
> break;
> std::iter_swap(__first, __last);
> ++__first;
> }
> }
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Predicate, typename _Distance>
> _ForwardIterator
> __inplace_stable_partition(_ForwardIterator __first,
> _Predicate __pred, _Distance __len)
> {
> if (__len == 1)
> return __first;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __len / 2);
> _ForwardIterator __left_split =
> std::__inplace_stable_partition(__first, __pred, __len / 2);
>
>
> _Distance __right_len = __len - __len / 2;
> _ForwardIterator __right_split =
> std::__find_if_not_n(__middle, __right_len, __pred);
> if (__right_len)
> __right_split = std::__inplace_stable_partition(__middle,
> __pred,
> __right_len);
> std::rotate(__left_split, __middle, __right_split);
> std::advance(__left_split, std::distance(__middle, __right_split));
> return __left_split;
> }
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
> typename _Distance>
> _ForwardIterator
> __stable_partition_adaptive(_ForwardIterator __first,
> _ForwardIterator __last,
> _Predicate __pred, _Distance __len,
> _Pointer __buffer,
> _Distance __buffer_size)
> {
> if (__len <= __buffer_size)
> {
> _ForwardIterator __result1 = __first;
> _Pointer __result2 = __buffer;
>
>
>
> *__result2 = std::move(*__first);
> ++__result2;
> ++__first;
> for (; __first != __last; ++__first)
> if (__pred(*__first))
> {
> *__result1 = std::move(*__first);
> ++__result1;
> }
> else
> {
> *__result2 = std::move(*__first);
> ++__result2;
> }
> std::move(__buffer, __result2, __result1);
> return __result1;
> }
> else
> {
> _ForwardIterator __middle = __first;
> std::advance(__middle, __len / 2);
> _ForwardIterator __left_split =
> std::__stable_partition_adaptive(__first, __middle, __pred,
> __len / 2, __buffer,
> __buffer_size);
>
>
> _Distance __right_len = __len - __len / 2;
> _ForwardIterator __right_split =
> std::__find_if_not_n(__middle, __right_len, __pred);
> if (__right_len)
> __right_split =
> std::__stable_partition_adaptive(__right_split, __last, __pred,
> __right_len,
> __buffer, __buffer_size);
> std::rotate(__left_split, __middle, __right_split);
> std::advance(__left_split, std::distance(__middle, __right_split));
> return __left_split;
> }
> }
># 1888 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> stable_partition(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
>
> 
>
> ;
>
> __first = std::__find_if_not(__first, __last, __pred);
>
> if (__first == __last)
> return __first;
> else
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
> _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first,
> __last);
> if (__buf.size() > 0)
> return
> std::__stable_partition_adaptive(__first, __last, __pred,
> _DistanceType(__buf.requested_size()),
> __buf.begin(),
> _DistanceType(__buf.size()));
> else
> return
> std::__inplace_stable_partition(__first, __pred,
> _DistanceType(__buf.requested_size()));
> }
> }
>
>
> template<typename _RandomAccessIterator>
> void
> __heap_select(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last)
> {
> std::make_heap(__first, __middle);
> for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
> if (*__i < *__first)
> std::__pop_heap(__first, __middle, __i);
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __heap_select(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last, _Compare __comp)
> {
> std::make_heap(__first, __middle, __comp);
> for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
> if (__comp(*__i, *__first))
> std::__pop_heap(__first, __middle, __i, __comp);
> }
># 1972 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _RandomAccessIterator>
> _RandomAccessIterator
> partial_sort_copy(_InputIterator __first, _InputIterator __last,
> _RandomAccessIterator __result_first,
> _RandomAccessIterator __result_last)
> {
> typedef typename iterator_traits<_InputIterator>::value_type
> _InputValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _OutputValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
> 
>
> 
>
> 
> ;
> ;
>
> if (__result_first == __result_last)
> return __result_last;
> _RandomAccessIterator __result_real_last = __result_first;
> while(__first != __last && __result_real_last != __result_last)
> {
> *__result_real_last = *__first;
> ++__result_real_last;
> ++__first;
> }
> std::make_heap(__result_first, __result_real_last);
> while (__first != __last)
> {
> if (*__first < *__result_first)
> std::__adjust_heap(__result_first, _DistanceType(0),
> _DistanceType(__result_real_last
> - __result_first),
> _InputValueType(*__first));
> ++__first;
> }
> std::sort_heap(__result_first, __result_real_last);
> return __result_real_last;
> }
># 2038 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _RandomAccessIterator, typename _Compare>
> _RandomAccessIterator
> partial_sort_copy(_InputIterator __first, _InputIterator __last,
> _RandomAccessIterator __result_first,
> _RandomAccessIterator __result_last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator>::value_type
> _InputValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _OutputValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
> 
>
> 
>
> 
>
> 
>
> ;
> ;
>
> if (__result_first == __result_last)
> return __result_last;
> _RandomAccessIterator __result_real_last = __result_first;
> while(__first != __last && __result_real_last != __result_last)
> {
> *__result_real_last = *__first;
> ++__result_real_last;
> ++__first;
> }
> std::make_heap(__result_first, __result_real_last, __comp);
> while (__first != __last)
> {
> if (__comp(*__first, *__result_first))
> std::__adjust_heap(__result_first, _DistanceType(0),
> _DistanceType(__result_real_last
> - __result_first),
> _InputValueType(*__first),
> __comp);
> ++__first;
> }
> std::sort_heap(__result_first, __result_real_last, __comp);
> return __result_real_last;
> }
>
>
> template<typename _RandomAccessIterator>
> void
> __unguarded_linear_insert(_RandomAccessIterator __last)
> {
> typename iterator_traits<_RandomAccessIterator>::value_type
> __val = std::move(*__last);
> _RandomAccessIterator __next = __last;
> --__next;
> while (__val < *__next)
> {
> *__last = std::move(*__next);
> __last = __next;
> --__next;
> }
> *__last = std::move(__val);
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __unguarded_linear_insert(_RandomAccessIterator __last,
> _Compare __comp)
> {
> typename iterator_traits<_RandomAccessIterator>::value_type
> __val = std::move(*__last);
> _RandomAccessIterator __next = __last;
> --__next;
> while (__comp(__val, *__next))
> {
> *__last = std::move(*__next);
> __last = __next;
> --__next;
> }
> *__last = std::move(__val);
> }
>
>
> template<typename _RandomAccessIterator>
> void
> __insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> if (__first == __last)
> return;
>
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> {
> if (*__i < *__first)
> {
> typename iterator_traits<_RandomAccessIterator>::value_type
> __val = std::move(*__i);
> std::move_backward(__first, __i, __i + 1);
> *__first = std::move(__val);
> }
> else
> std::__unguarded_linear_insert(__i);
> }
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> if (__first == __last) return;
>
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> {
> if (__comp(*__i, *__first))
> {
> typename iterator_traits<_RandomAccessIterator>::value_type
> __val = std::move(*__i);
> std::move_backward(__first, __i, __i + 1);
> *__first = std::move(__val);
> }
> else
> std::__unguarded_linear_insert(__i, __comp);
> }
> }
>
>
> template<typename _RandomAccessIterator>
> inline void
> __unguarded_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
> std::__unguarded_linear_insert(__i);
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> __unguarded_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
> std::__unguarded_linear_insert(__i, __comp);
> }
>
>
>
>
>
> enum { _S_threshold = 16 };
>
>
> template<typename _RandomAccessIterator>
> void
> __final_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> if (__last - __first > int(_S_threshold))
> {
> std::__insertion_sort(__first, __first + int(_S_threshold));
> std::__unguarded_insertion_sort(__first + int(_S_threshold), __last);
> }
> else
> std::__insertion_sort(__first, __last);
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __final_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> if (__last - __first > int(_S_threshold))
> {
> std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
> std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
> __comp);
> }
> else
> std::__insertion_sort(__first, __last, __comp);
> }
>
>
> template<typename _RandomAccessIterator, typename _Tp>
> _RandomAccessIterator
> __unguarded_partition(_RandomAccessIterator __first,
> _RandomAccessIterator __last, const _Tp& __pivot)
> {
> while (true)
> {
> while (*__first < __pivot)
> ++__first;
> --__last;
> while (__pivot < *__last)
> --__last;
> if (!(__first < __last))
> return __first;
> std::iter_swap(__first, __last);
> ++__first;
> }
> }
>
>
> template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
> _RandomAccessIterator
> __unguarded_partition(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> const _Tp& __pivot, _Compare __comp)
> {
> while (true)
> {
> while (__comp(*__first, __pivot))
> ++__first;
> --__last;
> while (__comp(__pivot, *__last))
> --__last;
> if (!(__first < __last))
> return __first;
> std::iter_swap(__first, __last);
> ++__first;
> }
> }
>
>
> template<typename _RandomAccessIterator>
> inline _RandomAccessIterator
> __unguarded_partition_pivot(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> _RandomAccessIterator __mid = __first + (__last - __first) / 2;
> std::__move_median_to_first(__first, __first + 1, __mid, __last - 1);
> return std::__unguarded_partition(__first + 1, __last, *__first);
> }
>
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline _RandomAccessIterator
> __unguarded_partition_pivot(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> _RandomAccessIterator __mid = __first + (__last - __first) / 2;
> std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
> __comp);
> return std::__unguarded_partition(__first + 1, __last, *__first, __comp);
> }
>
>
> template<typename _RandomAccessIterator, typename _Size>
> void
> __introsort_loop(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Size __depth_limit)
> {
> while (__last - __first > int(_S_threshold))
> {
> if (__depth_limit == 0)
> {
> std::partial_sort(__first, __last, __last);
> return;
> }
> --__depth_limit;
> _RandomAccessIterator __cut =
> std::__unguarded_partition_pivot(__first, __last);
> std::__introsort_loop(__cut, __last, __depth_limit);
> __last = __cut;
> }
> }
>
>
> template<typename _RandomAccessIterator, typename _Size, typename _Compare>
> void
> __introsort_loop(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Size __depth_limit, _Compare __comp)
> {
> while (__last - __first > int(_S_threshold))
> {
> if (__depth_limit == 0)
> {
> std::partial_sort(__first, __last, __last, __comp);
> return;
> }
> --__depth_limit;
> _RandomAccessIterator __cut =
> std::__unguarded_partition_pivot(__first, __last, __comp);
> std::__introsort_loop(__cut, __last, __depth_limit, __comp);
> __last = __cut;
> }
> }
>
>
>
> template<typename _RandomAccessIterator, typename _Size>
> void
> __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
> _RandomAccessIterator __last, _Size __depth_limit)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> while (__last - __first > 3)
> {
> if (__depth_limit == 0)
> {
> std::__heap_select(__first, __nth + 1, __last);
>
>
> std::iter_swap(__first, __nth);
> return;
> }
> --__depth_limit;
> _RandomAccessIterator __cut =
> std::__unguarded_partition_pivot(__first, __last);
> if (__cut <= __nth)
> __first = __cut;
> else
> __last = __cut;
> }
> std::__insertion_sort(__first, __last);
> }
>
> template<typename _RandomAccessIterator, typename _Size, typename _Compare>
> void
> __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
> _RandomAccessIterator __last, _Size __depth_limit,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> while (__last - __first > 3)
> {
> if (__depth_limit == 0)
> {
> std::__heap_select(__first, __nth + 1, __last, __comp);
>
> std::iter_swap(__first, __nth);
> return;
> }
> --__depth_limit;
> _RandomAccessIterator __cut =
> std::__unguarded_partition_pivot(__first, __last, __comp);
> if (__cut <= __nth)
> __first = __cut;
> else
> __last = __cut;
> }
> std::__insertion_sort(__first, __last, __comp);
> }
># 2423 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> _ForwardIterator
> lower_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
> 
> 
>
> 
> ;
>
> _DistanceType __len = std::distance(__first, __last);
>
> while (__len > 0)
> {
> _DistanceType __half = __len >> 1;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __half);
> if (__comp(*__middle, __val))
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else
> __len = __half;
> }
> return __first;
> }
># 2470 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> _ForwardIterator
> upper_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
> 
> 
> ;
>
> _DistanceType __len = std::distance(__first, __last);
>
> while (__len > 0)
> {
> _DistanceType __half = __len >> 1;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __half);
> if (__val < *__middle)
> __len = __half;
> else
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> }
> return __first;
> }
># 2519 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> _ForwardIterator
> upper_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
> 
> 
>
> 
> ;
>
> _DistanceType __len = std::distance(__first, __last);
>
> while (__len > 0)
> {
> _DistanceType __half = __len >> 1;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __half);
> if (__comp(__val, *__middle))
> __len = __half;
> else
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> }
> return __first;
> }
># 2572 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> pair<_ForwardIterator, _ForwardIterator>
> equal_range(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
> 
> 
> 
> ;
> ;
>
> _DistanceType __len = std::distance(__first, __last);
>
> while (__len > 0)
> {
> _DistanceType __half = __len >> 1;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __half);
> if (*__middle < __val)
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else if (__val < *__middle)
> __len = __half;
> else
> {
> _ForwardIterator __left = std::lower_bound(__first, __middle,
> __val);
> std::advance(__first, __len);
> _ForwardIterator __right = std::upper_bound(++__middle, __first,
> __val);
> return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
> }
> }
> return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
> }
># 2634 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> pair<_ForwardIterator, _ForwardIterator>
> equal_range(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
> 
> 
>
> 
>
> 
> ;
> 
> ;
>
> _DistanceType __len = std::distance(__first, __last);
>
> while (__len > 0)
> {
> _DistanceType __half = __len >> 1;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __half);
> if (__comp(*__middle, __val))
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else if (__comp(__val, *__middle))
> __len = __half;
> else
> {
> _ForwardIterator __left = std::lower_bound(__first, __middle,
> __val, __comp);
> std::advance(__first, __len);
> _ForwardIterator __right = std::upper_bound(++__middle, __first,
> __val, __comp);
> return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
> }
> }
> return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
> }
># 2695 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> bool
> binary_search(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
>
> 
> 
> ;
> ;
>
> _ForwardIterator __i = std::lower_bound(__first, __last, __val);
> return __i != __last && !(__val < *__i);
> }
># 2728 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> bool
> binary_search(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
>
> 
> 
>
> 
> ;
> 
> ;
>
> _ForwardIterator __i = std::lower_bound(__first, __last, __val, __comp);
> return __i != __last && !bool(__comp(__val, *__i));
> }
>
>
>
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> void
> __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (*__first2 < *__first1)
> {
> *__result = std::move(*__first2);
> ++__first2;
> }
> else
> {
> *__result = std::move(*__first1);
> ++__first1;
> }
> ++__result;
> }
> if (__first1 != __last1)
> std::move(__first1, __last1, __result);
> }
>
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> void
> __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (__comp(*__first2, *__first1))
> {
> *__result = std::move(*__first2);
> ++__first2;
> }
> else
> {
> *__result = std::move(*__first1);
> ++__first1;
> }
> ++__result;
> }
> if (__first1 != __last1)
> std::move(__first1, __last1, __result);
> }
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _BidirectionalIterator3>
> void
> __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> _BidirectionalIterator3 __result)
> {
> if (__first1 == __last1)
> {
> std::move_backward(__first2, __last2, __result);
> return;
> }
> else if (__first2 == __last2)
> return;
>
> --__last1;
> --__last2;
> while (true)
> {
> if (*__last2 < *__last1)
> {
> *--__result = std::move(*__last1);
> if (__first1 == __last1)
> {
> std::move_backward(__first2, ++__last2, __result);
> return;
> }
> --__last1;
> }
> else
> {
> *--__result = std::move(*__last2);
> if (__first2 == __last2)
> return;
> --__last2;
> }
> }
> }
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _BidirectionalIterator3, typename _Compare>
> void
> __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> _BidirectionalIterator3 __result,
> _Compare __comp)
> {
> if (__first1 == __last1)
> {
> std::move_backward(__first2, __last2, __result);
> return;
> }
> else if (__first2 == __last2)
> return;
>
> --__last1;
> --__last2;
> while (true)
> {
> if (__comp(*__last2, *__last1))
> {
> *--__result = std::move(*__last1);
> if (__first1 == __last1)
> {
> std::move_backward(__first2, ++__last2, __result);
> return;
> }
> --__last1;
> }
> else
> {
> *--__result = std::move(*__last2);
> if (__first2 == __last2)
> return;
> --__last2;
> }
> }
> }
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _Distance>
> _BidirectionalIterator1
> __rotate_adaptive(_BidirectionalIterator1 __first,
> _BidirectionalIterator1 __middle,
> _BidirectionalIterator1 __last,
> _Distance __len1, _Distance __len2,
> _BidirectionalIterator2 __buffer,
> _Distance __buffer_size)
> {
> _BidirectionalIterator2 __buffer_end;
> if (__len1 > __len2 && __len2 <= __buffer_size)
> {
> if (__len2)
> {
> __buffer_end = std::move(__middle, __last, __buffer);
> std::move_backward(__first, __middle, __last);
> return std::move(__buffer, __buffer_end, __first);
> }
> else
> return __first;
> }
> else if (__len1 <= __buffer_size)
> {
> if (__len1)
> {
> __buffer_end = std::move(__first, __middle, __buffer);
> std::move(__middle, __last, __first);
> return std::move_backward(__buffer, __buffer_end, __last);
> }
> else
> return __last;
> }
> else
> {
> std::rotate(__first, __middle, __last);
> std::advance(__first, std::distance(__middle, __last));
> return __first;
> }
> }
>
>
> template<typename _BidirectionalIterator, typename _Distance,
> typename _Pointer>
> void
> __merge_adaptive(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2,
> _Pointer __buffer, _Distance __buffer_size)
> {
> if (__len1 <= __len2 && __len1 <= __buffer_size)
> {
> _Pointer __buffer_end = std::move(__first, __middle, __buffer);
> std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
> __first);
> }
> else if (__len2 <= __buffer_size)
> {
> _Pointer __buffer_end = std::move(__middle, __last, __buffer);
> std::__move_merge_adaptive_backward(__first, __middle, __buffer,
> __buffer_end, __last);
> }
> else
> {
> _BidirectionalIterator __first_cut = __first;
> _BidirectionalIterator __second_cut = __middle;
> _Distance __len11 = 0;
> _Distance __len22 = 0;
> if (__len1 > __len2)
> {
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut = std::lower_bound(__middle, __last,
> *__first_cut);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut = std::upper_bound(__first, __middle,
> *__second_cut);
> __len11 = std::distance(__first, __first_cut);
> }
> _BidirectionalIterator __new_middle =
> std::__rotate_adaptive(__first_cut, __middle, __second_cut,
> __len1 - __len11, __len22, __buffer,
> __buffer_size);
> std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
> __len22, __buffer, __buffer_size);
> std::__merge_adaptive(__new_middle, __second_cut, __last,
> __len1 - __len11,
> __len2 - __len22, __buffer, __buffer_size);
> }
> }
>
>
> template<typename _BidirectionalIterator, typename _Distance,
> typename _Pointer, typename _Compare>
> void
> __merge_adaptive(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2,
> _Pointer __buffer, _Distance __buffer_size,
> _Compare __comp)
> {
> if (__len1 <= __len2 && __len1 <= __buffer_size)
> {
> _Pointer __buffer_end = std::move(__first, __middle, __buffer);
> std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
> __first, __comp);
> }
> else if (__len2 <= __buffer_size)
> {
> _Pointer __buffer_end = std::move(__middle, __last, __buffer);
> std::__move_merge_adaptive_backward(__first, __middle, __buffer,
> __buffer_end, __last, __comp);
> }
> else
> {
> _BidirectionalIterator __first_cut = __first;
> _BidirectionalIterator __second_cut = __middle;
> _Distance __len11 = 0;
> _Distance __len22 = 0;
> if (__len1 > __len2)
> {
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut = std::lower_bound(__middle, __last, *__first_cut,
> __comp);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut = std::upper_bound(__first, __middle, *__second_cut,
> __comp);
> __len11 = std::distance(__first, __first_cut);
> }
> _BidirectionalIterator __new_middle =
> std::__rotate_adaptive(__first_cut, __middle, __second_cut,
> __len1 - __len11, __len22, __buffer,
> __buffer_size);
> std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
> __len22, __buffer, __buffer_size, __comp);
> std::__merge_adaptive(__new_middle, __second_cut, __last,
> __len1 - __len11,
> __len2 - __len22, __buffer,
> __buffer_size, __comp);
> }
> }
>
>
> template<typename _BidirectionalIterator, typename _Distance>
> void
> __merge_without_buffer(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2)
> {
> if (__len1 == 0 || __len2 == 0)
> return;
> if (__len1 + __len2 == 2)
> {
> if (*__middle < *__first)
> std::iter_swap(__first, __middle);
> return;
> }
> _BidirectionalIterator __first_cut = __first;
> _BidirectionalIterator __second_cut = __middle;
> _Distance __len11 = 0;
> _Distance __len22 = 0;
> if (__len1 > __len2)
> {
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut = std::lower_bound(__middle, __last, *__first_cut);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut = std::upper_bound(__first, __middle, *__second_cut);
> __len11 = std::distance(__first, __first_cut);
> }
> std::rotate(__first_cut, __middle, __second_cut);
> _BidirectionalIterator __new_middle = __first_cut;
> std::advance(__new_middle, std::distance(__middle, __second_cut));
> std::__merge_without_buffer(__first, __first_cut, __new_middle,
> __len11, __len22);
> std::__merge_without_buffer(__new_middle, __second_cut, __last,
> __len1 - __len11, __len2 - __len22);
> }
>
>
> template<typename _BidirectionalIterator, typename _Distance,
> typename _Compare>
> void
> __merge_without_buffer(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2,
> _Compare __comp)
> {
> if (__len1 == 0 || __len2 == 0)
> return;
> if (__len1 + __len2 == 2)
> {
> if (__comp(*__middle, *__first))
> std::iter_swap(__first, __middle);
> return;
> }
> _BidirectionalIterator __first_cut = __first;
> _BidirectionalIterator __second_cut = __middle;
> _Distance __len11 = 0;
> _Distance __len22 = 0;
> if (__len1 > __len2)
> {
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut = std::lower_bound(__middle, __last, *__first_cut,
> __comp);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut = std::upper_bound(__first, __middle, *__second_cut,
> __comp);
> __len11 = std::distance(__first, __first_cut);
> }
> std::rotate(__first_cut, __middle, __second_cut);
> _BidirectionalIterator __new_middle = __first_cut;
> std::advance(__new_middle, std::distance(__middle, __second_cut));
> std::__merge_without_buffer(__first, __first_cut, __new_middle,
> __len11, __len22, __comp);
> std::__merge_without_buffer(__new_middle, __second_cut, __last,
> __len1 - __len11, __len2 - __len22, __comp);
> }
># 3152 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> void
> inplace_merge(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last)
> {
> typedef typename iterator_traits<_BidirectionalIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_BidirectionalIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
> ;
> ;
>
> if (__first == __middle || __middle == __last)
> return;
>
> _DistanceType __len1 = std::distance(__first, __middle);
> _DistanceType __len2 = std::distance(__middle, __last);
>
> _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
> __last);
> if (__buf.begin() == 0)
> std::__merge_without_buffer(__first, __middle, __last, __len1, __len2);
> else
> std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
> __buf.begin(), _DistanceType(__buf.size()));
> }
># 3207 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> void
> inplace_merge(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_BidirectionalIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_BidirectionalIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
>
> ;
> ;
>
> if (__first == __middle || __middle == __last)
> return;
>
> const _DistanceType __len1 = std::distance(__first, __middle);
> const _DistanceType __len2 = std::distance(__middle, __last);
>
> _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
> __last);
> if (__buf.begin() == 0)
> std::__merge_without_buffer(__first, __middle, __last, __len1,
> __len2, __comp);
> else
> std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
> __buf.begin(), _DistanceType(__buf.size()),
> __comp);
> }
>
>
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> __move_merge(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (*__first2 < *__first1)
> {
> *__result = std::move(*__first2);
> ++__first2;
> }
> else
> {
> *__result = std::move(*__first1);
> ++__first1;
> }
> ++__result;
> }
> return std::move(__first2, __last2, std::move(__first1, __last1, __result))
>
> ;
> }
>
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> __move_merge(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (__comp(*__first2, *__first1))
> {
> *__result = std::move(*__first2);
> ++__first2;
> }
> else
> {
> *__result = std::move(*__first1);
> ++__first1;
> }
> ++__result;
> }
> return std::move(__first2, __last2, std::move(__first1, __last1, __result))
>
> ;
> }
>
> template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
> typename _Distance>
> void
> __merge_sort_loop(_RandomAccessIterator1 __first,
> _RandomAccessIterator1 __last,
> _RandomAccessIterator2 __result,
> _Distance __step_size)
> {
> const _Distance __two_step = 2 * __step_size;
>
> while (__last - __first >= __two_step)
> {
> __result = std::__move_merge(__first, __first + __step_size,
> __first + __step_size,
> __first + __two_step, __result);
> __first += __two_step;
> }
>
> __step_size = std::min(_Distance(__last - __first), __step_size);
> std::__move_merge(__first, __first + __step_size,
> __first + __step_size, __last, __result);
> }
>
> template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
> typename _Distance, typename _Compare>
> void
> __merge_sort_loop(_RandomAccessIterator1 __first,
> _RandomAccessIterator1 __last,
> _RandomAccessIterator2 __result, _Distance __step_size,
> _Compare __comp)
> {
> const _Distance __two_step = 2 * __step_size;
>
> while (__last - __first >= __two_step)
> {
> __result = std::__move_merge(__first, __first + __step_size,
> __first + __step_size,
> __first + __two_step,
> __result, __comp);
> __first += __two_step;
> }
> __step_size = std::min(_Distance(__last - __first), __step_size);
>
> std::__move_merge(__first,__first + __step_size,
> __first + __step_size, __last, __result, __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Distance>
> void
> __chunk_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Distance __chunk_size)
> {
> while (__last - __first >= __chunk_size)
> {
> std::__insertion_sort(__first, __first + __chunk_size);
> __first += __chunk_size;
> }
> std::__insertion_sort(__first, __last);
> }
>
> template<typename _RandomAccessIterator, typename _Distance,
> typename _Compare>
> void
> __chunk_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Distance __chunk_size, _Compare __comp)
> {
> while (__last - __first >= __chunk_size)
> {
> std::__insertion_sort(__first, __first + __chunk_size, __comp);
> __first += __chunk_size;
> }
> std::__insertion_sort(__first, __last, __comp);
> }
>
> enum { _S_chunk_size = 7 };
>
> template<typename _RandomAccessIterator, typename _Pointer>
> void
> __merge_sort_with_buffer(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
>
> const _Distance __len = __last - __first;
> const _Pointer __buffer_last = __buffer + __len;
>
> _Distance __step_size = _S_chunk_size;
> std::__chunk_insertion_sort(__first, __last, __step_size);
>
> while (__step_size < __len)
> {
> std::__merge_sort_loop(__first, __last, __buffer, __step_size);
> __step_size *= 2;
> std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
> __step_size *= 2;
> }
> }
>
> template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
> void
> __merge_sort_with_buffer(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer, _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
>
> const _Distance __len = __last - __first;
> const _Pointer __buffer_last = __buffer + __len;
>
> _Distance __step_size = _S_chunk_size;
> std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
>
> while (__step_size < __len)
> {
> std::__merge_sort_loop(__first, __last, __buffer,
> __step_size, __comp);
> __step_size *= 2;
> std::__merge_sort_loop(__buffer, __buffer_last, __first,
> __step_size, __comp);
> __step_size *= 2;
> }
> }
>
> template<typename _RandomAccessIterator, typename _Pointer,
> typename _Distance>
> void
> __stable_sort_adaptive(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer, _Distance __buffer_size)
> {
> const _Distance __len = (__last - __first + 1) / 2;
> const _RandomAccessIterator __middle = __first + __len;
> if (__len > __buffer_size)
> {
> std::__stable_sort_adaptive(__first, __middle,
> __buffer, __buffer_size);
> std::__stable_sort_adaptive(__middle, __last,
> __buffer, __buffer_size);
> }
> else
> {
> std::__merge_sort_with_buffer(__first, __middle, __buffer);
> std::__merge_sort_with_buffer(__middle, __last, __buffer);
> }
> std::__merge_adaptive(__first, __middle, __last,
> _Distance(__middle - __first),
> _Distance(__last - __middle),
> __buffer, __buffer_size);
> }
>
> template<typename _RandomAccessIterator, typename _Pointer,
> typename _Distance, typename _Compare>
> void
> __stable_sort_adaptive(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer, _Distance __buffer_size,
> _Compare __comp)
> {
> const _Distance __len = (__last - __first + 1) / 2;
> const _RandomAccessIterator __middle = __first + __len;
> if (__len > __buffer_size)
> {
> std::__stable_sort_adaptive(__first, __middle, __buffer,
> __buffer_size, __comp);
> std::__stable_sort_adaptive(__middle, __last, __buffer,
> __buffer_size, __comp);
> }
> else
> {
> std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
> std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
> }
> std::__merge_adaptive(__first, __middle, __last,
> _Distance(__middle - __first),
> _Distance(__last - __middle),
> __buffer, __buffer_size,
> __comp);
> }
>
>
> template<typename _RandomAccessIterator>
> void
> __inplace_stable_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> if (__last - __first < 15)
> {
> std::__insertion_sort(__first, __last);
> return;
> }
> _RandomAccessIterator __middle = __first + (__last - __first) / 2;
> std::__inplace_stable_sort(__first, __middle);
> std::__inplace_stable_sort(__middle, __last);
> std::__merge_without_buffer(__first, __middle, __last,
> __middle - __first,
> __last - __middle);
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __inplace_stable_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> if (__last - __first < 15)
> {
> std::__insertion_sort(__first, __last, __comp);
> return;
> }
> _RandomAccessIterator __middle = __first + (__last - __first) / 2;
> std::__inplace_stable_sort(__first, __middle, __comp);
> std::__inplace_stable_sort(__middle, __last, __comp);
> std::__merge_without_buffer(__first, __middle, __last,
> __middle - __first,
> __last - __middle,
> __comp);
> }
># 3547 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2>
> bool
> includes(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
> 
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first2 < *__first1)
> return false;
> else if(*__first1 < *__first2)
> ++__first1;
> else
> ++__first1, ++__first2;
>
> return __first2 == __last2;
> }
># 3597 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _Compare>
> bool
> includes(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first2, *__first1))
> return false;
> else if(__comp(*__first1, *__first2))
> ++__first1;
> else
> ++__first1, ++__first2;
>
> return __first2 == __last2;
> }
># 3652 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> bool
> next_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last)
> {
>
> 
>
> 
>
> ;
>
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (*__i < *__ii)
> {
> _BidirectionalIterator __j = __last;
> while (!(*__i < *--__j))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 3709 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> bool
> next_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last, _Compare __comp)
> {
>
> 
>
> 
>
>
> ;
>
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (__comp(*__i, *__ii))
> {
> _BidirectionalIterator __j = __last;
> while (!bool(__comp(*__i, *--__j)))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 3765 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> bool
> prev_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last)
> {
>
> 
>
> 
>
> ;
>
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (*__ii < *__i)
> {
> _BidirectionalIterator __j = __last;
> while (!(*--__j < *__i))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 3822 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> bool
> prev_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last, _Compare __comp)
> {
>
> 
>
> 
>
>
> ;
>
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (__comp(*__ii, *__i))
> {
> _BidirectionalIterator __j = __last;
> while (!bool(__comp(*--__j, *__i)))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 3882 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator, typename _Tp>
> _OutputIterator
> replace_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> const _Tp& __old_value, const _Tp& __new_value)
> {
>
> 
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first, ++__result)
> if (*__first == __old_value)
> *__result = __new_value;
> else
> *__result = *__first;
> return __result;
> }
># 3919 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _Predicate, typename _Tp>
> _OutputIterator
> replace_copy_if(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> _Predicate __pred, const _Tp& __new_value)
> {
>
> 
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first, ++__result)
> if (__pred(*__first))
> *__result = __new_value;
> else
> *__result = *__first;
> return __result;
> }
># 3950 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> inline bool
> is_sorted(_ForwardIterator __first, _ForwardIterator __last)
> { return std::is_sorted_until(__first, __last) == __last; }
># 3964 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> inline bool
> is_sorted(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> { return std::is_sorted_until(__first, __last, __comp) == __last; }
># 3978 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __last;
>
> _ForwardIterator __next = __first;
> for (++__next; __next != __last; __first = __next, ++__next)
> if (*__next < *__first)
> return __next;
> return __next;
> }
># 4007 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> _ForwardIterator
> is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
>
> 
> 
>
>
> ;
>
> if (__first == __last)
> return __last;
>
> _ForwardIterator __next = __first;
> for (++__next; __next != __last; __first = __next, ++__next)
> if (__comp(*__next, *__first))
> return __next;
> return __next;
> }
># 4037 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _Tp>
> inline pair<const _Tp&, const _Tp&>
> minmax(const _Tp& __a, const _Tp& __b)
> {
>
> 
>
> return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
> : pair<const _Tp&, const _Tp&>(__a, __b);
> }
># 4057 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _Tp, typename _Compare>
> inline pair<const _Tp&, const _Tp&>
> minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
> {
> return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
> : pair<const _Tp&, const _Tp&>(__a, __b);
> }
># 4076 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> pair<_ForwardIterator, _ForwardIterator>
> minmax_element(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
>
> _ForwardIterator __next = __first;
> if (__first == __last
> || ++__next == __last)
> return std::make_pair(__first, __first);
>
> _ForwardIterator __min, __max;
> if (*__next < *__first)
> {
> __min = __next;
> __max = __first;
> }
> else
> {
> __min = __first;
> __max = __next;
> }
>
> __first = __next;
> ++__first;
>
> while (__first != __last)
> {
> __next = __first;
> if (++__next == __last)
> {
> if (*__first < *__min)
> __min = __first;
> else if (!(*__first < *__max))
> __max = __first;
> break;
> }
>
> if (*__next < *__first)
> {
> if (*__next < *__min)
> __min = __next;
> if (!(*__first < *__max))
> __max = __first;
> }
> else
> {
> if (*__first < *__min)
> __min = __first;
> if (!(*__next < *__max))
> __max = __next;
> }
>
> __first = __next;
> ++__first;
> }
>
> return std::make_pair(__min, __max);
> }
># 4152 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> pair<_ForwardIterator, _ForwardIterator>
> minmax_element(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
>
> 
> 
>
>
> ;
>
> _ForwardIterator __next = __first;
> if (__first == __last
> || ++__next == __last)
> return std::make_pair(__first, __first);
>
> _ForwardIterator __min, __max;
> if (__comp(*__next, *__first))
> {
> __min = __next;
> __max = __first;
> }
> else
> {
> __min = __first;
> __max = __next;
> }
>
> __first = __next;
> ++__first;
>
> while (__first != __last)
> {
> __next = __first;
> if (++__next == __last)
> {
> if (__comp(*__first, *__min))
> __min = __first;
> else if (!__comp(*__first, *__max))
> __max = __first;
> break;
> }
>
> if (__comp(*__next, *__first))
> {
> if (__comp(*__next, *__min))
> __min = __next;
> if (!__comp(*__first, *__max))
> __max = __first;
> }
> else
> {
> if (__comp(*__first, *__min))
> __min = __first;
> if (!__comp(*__next, *__max))
> __max = __next;
> }
>
> __first = __next;
> ++__first;
> }
>
> return std::make_pair(__min, __max);
> }
>
>
> template<typename _Tp>
> inline _Tp
> min(initializer_list<_Tp> __l)
> { return *std::min_element(__l.begin(), __l.end()); }
>
> template<typename _Tp, typename _Compare>
> inline _Tp
> min(initializer_list<_Tp> __l, _Compare __comp)
> { return *std::min_element(__l.begin(), __l.end(), __comp); }
>
> template<typename _Tp>
> inline _Tp
> max(initializer_list<_Tp> __l)
> { return *std::max_element(__l.begin(), __l.end()); }
>
> template<typename _Tp, typename _Compare>
> inline _Tp
> max(initializer_list<_Tp> __l, _Compare __comp)
> { return *std::max_element(__l.begin(), __l.end(), __comp); }
>
> template<typename _Tp>
> inline pair<_Tp, _Tp>
> minmax(initializer_list<_Tp> __l)
> {
> pair<const _Tp*, const _Tp*> __p =
> std::minmax_element(__l.begin(), __l.end());
> return std::make_pair(*__p.first, *__p.second);
> }
>
> template<typename _Tp, typename _Compare>
> inline pair<_Tp, _Tp>
> minmax(initializer_list<_Tp> __l, _Compare __comp)
> {
> pair<const _Tp*, const _Tp*> __p =
> std::minmax_element(__l.begin(), __l.end(), __comp);
> return std::make_pair(*__p.first, *__p.second);
> }
># 4269 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> bool
> is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2)
> {
>
>
> for (; __first1 != __last1; ++__first1, ++__first2)
> if (!(*__first1 == *__first2))
> break;
>
> if (__first1 == __last1)
> return true;
>
>
>
> _ForwardIterator2 __last2 = __first2;
> std::advance(__last2, std::distance(__first1, __last1));
> for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
> {
> if (__scan != std::find(__first1, __scan, *__scan))
> continue;
>
> auto __matches = std::count(__first2, __last2, *__scan);
> if (0 == __matches
> || std::count(__scan, __last1, *__scan) != __matches)
> return false;
> }
> return true;
> }
># 4314 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> bool
> is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _BinaryPredicate __pred)
> {
>
>
> for (; __first1 != __last1; ++__first1, ++__first2)
> if (!bool(__pred(*__first1, *__first2)))
> break;
>
> if (__first1 == __last1)
> return true;
>
>
>
> _ForwardIterator2 __last2 = __first2;
> std::advance(__last2, std::distance(__first1, __last1));
> for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
> {
> using std::placeholders::_1;
>
> if (__scan != std::find_if(__first1, __scan,
> std::bind(__pred, _1, *__scan)))
> continue;
>
> auto __matches = std::count_if(__first2, __last2,
> std::bind(__pred, _1, *__scan));
> if (0 == __matches
> || std::count_if(__scan, __last1,
> std::bind(__pred, _1, *__scan)) != __matches)
> return false;
> }
> return true;
> }
># 4364 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator,
> typename _UniformRandomNumberGenerator>
> void
> shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _UniformRandomNumberGenerator&& __g)
> {
>
> 
>
> ;
>
> if (__first == __last)
> return;
>
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
> typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
> typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
> typedef typename __distr_type::param_type __p_type;
> __distr_type __d;
>
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
> }
>
>
>
>
>
>
>
># 4409 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Function>
> _Function
> for_each(_InputIterator __first, _InputIterator __last, _Function __f)
> {
>
> 
> ;
> for (; __first != __last; ++__first)
> __f(*__first);
> return std::move(__f);
> }
># 4430 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Tp>
> inline _InputIterator
> find(_InputIterator __first, _InputIterator __last,
> const _Tp& __val)
> {
>
> 
> 
>
> ;
> return std::__find(__first, __last, __val,
> std::__iterator_category(__first));
> }
># 4454 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> find_if(_InputIterator __first, _InputIterator __last,
> _Predicate __pred)
> {
>
> 
> 
>
> ;
> return std::__find_if(__first, __last, __pred,
> std::__iterator_category(__first));
> }
># 4484 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _ForwardIterator>
> _InputIterator
> find_first_of(_InputIterator __first1, _InputIterator __last1,
> _ForwardIterator __first2, _ForwardIterator __last2)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> for (; __first1 != __last1; ++__first1)
> for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
> if (*__first1 == *__iter)
> return __first1;
> return __last1;
> }
># 4524 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _ForwardIterator,
> typename _BinaryPredicate>
> _InputIterator
> find_first_of(_InputIterator __first1, _InputIterator __last1,
> _ForwardIterator __first2, _ForwardIterator __last2,
> _BinaryPredicate __comp)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> for (; __first1 != __last1; ++__first1)
> for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
> if (__comp(*__first1, *__iter))
> return __first1;
> return __last1;
> }
># 4556 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
> if (__first == __last)
> return __last;
> _ForwardIterator __next = __first;
> while(++__next != __last)
> {
> if (*__first == *__next)
> return __first;
> __first = __next;
> }
> return __last;
> }
># 4588 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _BinaryPredicate>
> _ForwardIterator
> adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
>
>
> ;
> if (__first == __last)
> return __last;
> _ForwardIterator __next = __first;
> while(++__next != __last)
> {
> if (__binary_pred(*__first, *__next))
> return __first;
> __first = __next;
> }
> return __last;
> }
># 4620 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Tp>
> typename iterator_traits<_InputIterator>::difference_type
> count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
> {
>
> 
> 
>
> ;
> typename iterator_traits<_InputIterator>::difference_type __n = 0;
> for (; __first != __last; ++__first)
> if (*__first == __value)
> ++__n;
> return __n;
> }
># 4645 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> typename iterator_traits<_InputIterator>::difference_type
> count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
> {
>
> 
> 
>
> ;
> typename iterator_traits<_InputIterator>::difference_type __n = 0;
> for (; __first != __last; ++__first)
> if (__pred(*__first))
> ++__n;
> return __n;
> }
># 4687 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> _ForwardIterator1
> search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
>
> if (__first1 == __last1 || __first2 == __last2)
> return __first1;
>
>
> _ForwardIterator2 __p1(__first2);
> if (++__p1 == __last2)
> return std::find(__first1, __last1, *__first2);
>
>
> _ForwardIterator2 __p;
> _ForwardIterator1 __current = __first1;
>
> for (;;)
> {
> __first1 = std::find(__first1, __last1, *__first2);
> if (__first1 == __last1)
> return __last1;
>
> __p = __p1;
> __current = __first1;
> if (++__current == __last1)
> return __last1;
>
> while (*__current == *__p)
> {
> if (++__p == __last2)
> return __first1;
> if (++__current == __last1)
> return __last1;
> }
> ++__first1;
> }
> return __first1;
> }
># 4758 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> _ForwardIterator1
> search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> _BinaryPredicate __predicate)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
>
> if (__first1 == __last1 || __first2 == __last2)
> return __first1;
>
>
> _ForwardIterator2 __p1(__first2);
> if (++__p1 == __last2)
> {
> while (__first1 != __last1
> && !bool(__predicate(*__first1, *__first2)))
> ++__first1;
> return __first1;
> }
>
>
> _ForwardIterator2 __p;
> _ForwardIterator1 __current = __first1;
>
> for (;;)
> {
> while (__first1 != __last1
> && !bool(__predicate(*__first1, *__first2)))
> ++__first1;
> if (__first1 == __last1)
> return __last1;
>
> __p = __p1;
> __current = __first1;
> if (++__current == __last1)
> return __last1;
>
> while (__predicate(*__current, *__p))
> {
> if (++__p == __last2)
> return __first1;
> if (++__current == __last1)
> return __last1;
> }
> ++__first1;
> }
> return __first1;
> }
># 4833 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp>
> _ForwardIterator
> search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val)
> {
>
> 
> 
>
> ;
>
> if (__count <= 0)
> return __first;
> if (__count == 1)
> return std::find(__first, __last, __val);
> return std::__search_n(__first, __last, __count, __val,
> std::__iterator_category(__first));
> }
># 4870 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp,
> typename _BinaryPredicate>
> _ForwardIterator
> search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
>
> ;
>
> if (__count <= 0)
> return __first;
> if (__count == 1)
> {
> while (__first != __last && !bool(__binary_pred(*__first, __val)))
> ++__first;
> return __first;
> }
> return std::__search_n(__first, __last, __count, __val, __binary_pred,
> std::__iterator_category(__first));
> }
># 4912 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _UnaryOperation>
> _OutputIterator
> transform(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _UnaryOperation __unary_op)
> {
>
> 
> 
>
>
> ;
>
> for (; __first != __last; ++__first, ++__result)
> *__result = __unary_op(*__first);
> return __result;
> }
># 4949 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _BinaryOperation>
> _OutputIterator
> transform(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _OutputIterator __result,
> _BinaryOperation __binary_op)
> {
>
> 
> 
> 
>
>
> ;
>
> for (; __first1 != __last1; ++__first1, ++__first2, ++__result)
> *__result = __binary_op(*__first1, *__first2);
> return __result;
> }
># 4982 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> void
> replace(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __old_value, const _Tp& __new_value)
> {
>
> 
>
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> if (*__first == __old_value)
> *__first = __new_value;
> }
># 5014 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate, typename _Tp>
> void
> replace_if(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred, const _Tp& __new_value)
> {
>
> 
>
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> if (__pred(*__first))
> *__first = __new_value;
> }
># 5046 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Generator>
> void
> generate(_ForwardIterator __first, _ForwardIterator __last,
> _Generator __gen)
> {
>
> 
> 
>
> ;
>
> for (; __first != __last; ++__first)
> *__first = __gen();
> }
># 5077 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _OutputIterator, typename _Size, typename _Generator>
> _OutputIterator
> generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
> {
>
> 
>
>
>
> for (__decltype(__n + 0) __niter = __n;
> __niter > 0; --__niter, ++__first)
> *__first = __gen();
> return __first;
> }
># 5114 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator>
> inline _OutputIterator
> unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result)
> {
>
> 
> 
>
> 
>
> ;
>
> if (__first == __last)
> return __result;
> return std::__unique_copy(__first, __last, __result,
> std::__iterator_category(__first),
> std::__iterator_category(__result));
> }
># 5153 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _BinaryPredicate>
> inline _OutputIterator
> unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __result;
> return std::__unique_copy(__first, __last, __result, __binary_pred,
> std::__iterator_category(__first),
> std::__iterator_category(__result));
> }
># 5185 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> ;
>
> if (__first != __last)
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));
> }
># 5213 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
> void
> random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
>
> _RandomNumberGenerator&& __rand)
>
>
>
> {
>
> 
>
> ;
>
> if (__first == __last)
> return;
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> std::iter_swap(__i, __first + __rand((__i - __first) + 1));
> }
># 5249 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> inline _ForwardIterator
> partition(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
>
> 
>
> ;
>
> return std::__partition(__first, __last, __pred,
> std::__iterator_category(__first));
> }
># 5283 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> partial_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
> ;
>
> std::__heap_select(__first, __middle, __last);
> std::sort_heap(__first, __middle);
> }
># 5322 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> partial_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
>
> ;
> ;
>
> std::__heap_select(__first, __middle, __last, __comp);
> std::sort_heap(__first, __middle, __comp);
> }
># 5359 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
> _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
> ;
>
> if (__first == __last || __nth == __last)
> return;
>
> std::__introselect(__first, __nth, __last,
> std::__lg(__last - __first) * 2);
> }
># 5398 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
> _RandomAccessIterator __last, _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
>
> ;
> ;
>
> if (__first == __last || __nth == __last)
> return;
>
> std::__introselect(__first, __nth, __last,
> std::__lg(__last - __first) * 2, __comp);
> }
># 5436 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
>
> if (__first != __last)
> {
> std::__introsort_loop(__first, __last,
> std::__lg(__last - __first) * 2);
> std::__final_insertion_sort(__first, __last);
> }
> }
># 5472 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
>
> ;
>
> if (__first != __last)
> {
> std::__introsort_loop(__first, __last,
> std::__lg(__last - __first) * 2, __comp);
> std::__final_insertion_sort(__first, __last, __comp);
> }
> }
># 5514 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> merge(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (*__first2 < *__first1)
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> }
> ++__result;
> }
> return std::copy(__first2, __last2, std::copy(__first1, __last1,
> __result));
> }
># 5578 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> merge(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (__comp(*__first2, *__first1))
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> }
> ++__result;
> }
> return std::copy(__first2, __last2, std::copy(__first1, __last1,
> __result));
> }
># 5638 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
> ;
>
> _Temporary_buffer<_RandomAccessIterator, _ValueType> __buf(__first,
> __last);
> if (__buf.begin() == 0)
> std::__inplace_stable_sort(__first, __last);
> else
> std::__stable_sort_adaptive(__first, __last, __buf.begin(),
> _DistanceType(__buf.size()));
> }
># 5680 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
>
>
> ;
>
> _Temporary_buffer<_RandomAccessIterator, _ValueType> __buf(__first,
> __last);
> if (__buf.begin() == 0)
> std::__inplace_stable_sort(__first, __last, __comp);
> else
> std::__stable_sort_adaptive(__first, __last, __buf.begin(),
> _DistanceType(__buf.size()), __comp);
> }
># 5726 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_union(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
> 
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (*__first1 < *__first2)
> {
> *__result = *__first1;
> ++__first1;
> }
> else if (*__first2 < *__first1)
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> }
> ++__result;
> }
> return std::copy(__first2, __last2, std::copy(__first1, __last1,
> __result));
> }
># 5793 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_union(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (__comp(*__first1, *__first2))
> {
> *__result = *__first1;
> ++__first1;
> }
> else if (__comp(*__first2, *__first1))
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> }
> ++__result;
> }
> return std::copy(__first2, __last2, std::copy(__first1, __last1,
> __result));
> }
># 5860 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
> 
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first1 < *__first2)
> ++__first1;
> else if (*__first2 < *__first1)
> ++__first2;
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> ++__result;
> }
> return __result;
> }
># 5917 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first1, *__first2))
> ++__first1;
> else if (__comp(*__first2, *__first1))
> ++__first2;
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> ++__result;
> }
> return __result;
> }
># 5975 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
> 
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first1 < *__first2)
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (*__first2 < *__first1)
> ++__first2;
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first1, __last1, __result);
> }
># 6036 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first1, *__first2))
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (__comp(*__first2, *__first1))
> ++__first2;
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first1, __last1, __result);
> }
># 6094 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
> 
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first1 < *__first2)
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (*__first2 < *__first1)
> {
> *__result = *__first2;
> ++__first2;
> ++__result;
> }
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first2, __last2, std::copy(__first1,
> __last1, __result));
> }
># 6160 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result,
> _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first1, *__first2))
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (__comp(*__first2, *__first1))
> {
> *__result = *__first2;
> ++__first2;
> ++__result;
> }
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first2, __last2,
> std::copy(__first1, __last1, __result));
> }
># 6217 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> min_element(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (*__first < *__result)
> __result = __first;
> return __result;
> }
># 6245 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> _ForwardIterator
> min_element(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
>
> 
> 
>
>
> ;
>
> if (__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (__comp(*__first, *__result))
> __result = __first;
> return __result;
> }
># 6273 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> max_element(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (*__result < *__first)
> __result = __first;
> return __result;
> }
># 6301 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> _ForwardIterator
> max_element(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
>
> 
> 
>
>
> ;
>
> if (__first == __last) return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (__comp(*__result, *__first))
> __result = __first;
> return __result;
> }
>
>
>}
># 63 "/usr/include/c++/4.8.2/algorithm" 2 3
># 25 "/usr/include/boost/circular_buffer/base.hpp" 2 3 4
>
># 1 "/usr/include/c++/4.8.2/deque" 1 3 4
># 58 "/usr/include/c++/4.8.2/deque" 3 4
> 
># 59 "/usr/include/c++/4.8.2/deque" 3
>
>
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/stl_deque.h" 1 3
># 66 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 88 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> inline size_t
> __deque_buf_size(size_t __size)
> { return (__size < 512
> ? size_t(512 / __size) : size_t(1)); }
># 105 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> template<typename _Tp, typename _Ref, typename _Ptr>
> struct _Deque_iterator
> {
> typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
> typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
>
> static size_t _S_buffer_size()
> { return __deque_buf_size(sizeof(_Tp)); }
>
> typedef std::random_access_iterator_tag iterator_category;
> typedef _Tp value_type;
> typedef _Ptr pointer;
> typedef _Ref reference;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Tp** _Map_pointer;
> typedef _Deque_iterator _Self;
>
> _Tp* _M_cur;
> _Tp* _M_first;
> _Tp* _M_last;
> _Map_pointer _M_node;
>
> _Deque_iterator(_Tp* __x, _Map_pointer __y)
> : _M_cur(__x), _M_first(*__y),
> _M_last(*__y + _S_buffer_size()), _M_node(__y) { }
>
> _Deque_iterator()
> : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) { }
>
> _Deque_iterator(const iterator& __x)
> : _M_cur(__x._M_cur), _M_first(__x._M_first),
> _M_last(__x._M_last), _M_node(__x._M_node) { }
>
> reference
> operator*() const
> { return *_M_cur; }
>
> pointer
> operator->() const
> { return _M_cur; }
>
> _Self&
> operator++()
> {
> ++_M_cur;
> if (_M_cur == _M_last)
> {
> _M_set_node(_M_node + 1);
> _M_cur = _M_first;
> }
> return *this;
> }
>
> _Self
> operator++(int)
> {
> _Self __tmp = *this;
> ++*this;
> return __tmp;
> }
>
> _Self&
> operator--()
> {
> if (_M_cur == _M_first)
> {
> _M_set_node(_M_node - 1);
> _M_cur = _M_last;
> }
> --_M_cur;
> return *this;
> }
>
> _Self
> operator--(int)
> {
> _Self __tmp = *this;
> --*this;
> return __tmp;
> }
>
> _Self&
> operator+=(difference_type __n)
> {
> const difference_type __offset = __n + (_M_cur - _M_first);
> if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
> _M_cur += __n;
> else
> {
> const difference_type __node_offset =
> __offset > 0 ? __offset / difference_type(_S_buffer_size())
> : -difference_type((-__offset - 1)
> / _S_buffer_size()) - 1;
> _M_set_node(_M_node + __node_offset);
> _M_cur = _M_first + (__offset - __node_offset
> * difference_type(_S_buffer_size()));
> }
> return *this;
> }
>
> _Self
> operator+(difference_type __n) const
> {
> _Self __tmp = *this;
> return __tmp += __n;
> }
>
> _Self&
> operator-=(difference_type __n)
> { return *this += -__n; }
>
> _Self
> operator-(difference_type __n) const
> {
> _Self __tmp = *this;
> return __tmp -= __n;
> }
>
> reference
> operator[](difference_type __n) const
> { return *(*this + __n); }
>
>
>
>
>
>
> void
> _M_set_node(_Map_pointer __new_node)
> {
> _M_node = __new_node;
> _M_first = *__new_node;
> _M_last = _M_first + difference_type(_S_buffer_size());
> }
> };
>
>
>
>
> template<typename _Tp, typename _Ref, typename _Ptr>
> inline bool
> operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
> const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
> { return __x._M_cur == __y._M_cur; }
>
> template<typename _Tp, typename _RefL, typename _PtrL,
> typename _RefR, typename _PtrR>
> inline bool
> operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
> const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
> { return __x._M_cur == __y._M_cur; }
>
> template<typename _Tp, typename _Ref, typename _Ptr>
> inline bool
> operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
> const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
> { return !(__x == __y); }
>
> template<typename _Tp, typename _RefL, typename _PtrL,
> typename _RefR, typename _PtrR>
> inline bool
> operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
> const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
> { return !(__x == __y); }
>
> template<typename _Tp, typename _Ref, typename _Ptr>
> inline bool
> operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
> const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
> { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
> : (__x._M_node < __y._M_node); }
>
> template<typename _Tp, typename _RefL, typename _PtrL,
> typename _RefR, typename _PtrR>
> inline bool
> operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
> const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
> { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
> : (__x._M_node < __y._M_node); }
>
> template<typename _Tp, typename _Ref, typename _Ptr>
> inline bool
> operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
> const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
> { return __y < __x; }
>
> template<typename _Tp, typename _RefL, typename _PtrL,
> typename _RefR, typename _PtrR>
> inline bool
> operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
> const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
> { return __y < __x; }
>
> template<typename _Tp, typename _Ref, typename _Ptr>
> inline bool
> operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
> const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
> { return !(__y < __x); }
>
> template<typename _Tp, typename _RefL, typename _PtrL,
> typename _RefR, typename _PtrR>
> inline bool
> operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
> const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
> { return !(__y < __x); }
>
> template<typename _Tp, typename _Ref, typename _Ptr>
> inline bool
> operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
> const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
> { return !(__x < __y); }
>
> template<typename _Tp, typename _RefL, typename _PtrL,
> typename _RefR, typename _PtrR>
> inline bool
> operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
> const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
> { return !(__x < __y); }
>
>
>
>
>
> template<typename _Tp, typename _Ref, typename _Ptr>
> inline typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
> operator-(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
> const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
> {
> return typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
> (_Deque_iterator<_Tp, _Ref, _Ptr>::_S_buffer_size())
> * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
> + (__y._M_last - __y._M_cur);
> }
>
> template<typename _Tp, typename _RefL, typename _PtrL,
> typename _RefR, typename _PtrR>
> inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
> operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
> const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
> {
> return typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
> (_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size())
> * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
> + (__y._M_last - __y._M_cur);
> }
>
> template<typename _Tp, typename _Ref, typename _Ptr>
> inline _Deque_iterator<_Tp, _Ref, _Ptr>
> operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
> { return __x + __n; }
>
> template<typename _Tp>
> void
> fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>&,
> const _Deque_iterator<_Tp, _Tp&, _Tp*>&, const _Tp&);
>
> template<typename _Tp>
> _Deque_iterator<_Tp, _Tp&, _Tp*>
> copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
> _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
> _Deque_iterator<_Tp, _Tp&, _Tp*>);
>
> template<typename _Tp>
> inline _Deque_iterator<_Tp, _Tp&, _Tp*>
> copy(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
> _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
> _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
> { return std::copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
> _Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last),
> __result); }
>
> template<typename _Tp>
> _Deque_iterator<_Tp, _Tp&, _Tp*>
> copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
> _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
> _Deque_iterator<_Tp, _Tp&, _Tp*>);
>
> template<typename _Tp>
> inline _Deque_iterator<_Tp, _Tp&, _Tp*>
> copy_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
> _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
> _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
> { return std::copy_backward(_Deque_iterator<_Tp,
> const _Tp&, const _Tp*>(__first),
> _Deque_iterator<_Tp,
> const _Tp&, const _Tp*>(__last),
> __result); }
>
>
> template<typename _Tp>
> _Deque_iterator<_Tp, _Tp&, _Tp*>
> move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
> _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
> _Deque_iterator<_Tp, _Tp&, _Tp*>);
>
> template<typename _Tp>
> inline _Deque_iterator<_Tp, _Tp&, _Tp*>
> move(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
> _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
> _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
> { return std::move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
> _Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last),
> __result); }
>
> template<typename _Tp>
> _Deque_iterator<_Tp, _Tp&, _Tp*>
> move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
> _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
> _Deque_iterator<_Tp, _Tp&, _Tp*>);
>
> template<typename _Tp>
> inline _Deque_iterator<_Tp, _Tp&, _Tp*>
> move_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
> _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
> _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
> { return std::move_backward(_Deque_iterator<_Tp,
> const _Tp&, const _Tp*>(__first),
> _Deque_iterator<_Tp,
> const _Tp&, const _Tp*>(__last),
> __result); }
># 438 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> template<typename _Tp, typename _Alloc>
> class _Deque_base
> {
> public:
> typedef _Alloc allocator_type;
>
> allocator_type
> get_allocator() const noexcept
> { return allocator_type(_M_get_Tp_allocator()); }
>
> typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
> typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
>
> _Deque_base()
> : _M_impl()
> { _M_initialize_map(0); }
>
> _Deque_base(size_t __num_elements)
> : _M_impl()
> { _M_initialize_map(__num_elements); }
>
> _Deque_base(const allocator_type& __a, size_t __num_elements)
> : _M_impl(__a)
> { _M_initialize_map(__num_elements); }
>
> _Deque_base(const allocator_type& __a)
> : _M_impl(__a)
> { }
>
>
> _Deque_base(_Deque_base&& __x)
> : _M_impl(std::move(__x._M_get_Tp_allocator()))
> {
> _M_initialize_map(0);
> if (__x._M_impl._M_map)
> {
> std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
> std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
> std::swap(this->_M_impl._M_map, __x._M_impl._M_map);
> std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size);
> }
> }
>
>
> ~_Deque_base();
>
> protected:
>
>
>
> typedef typename _Alloc::template rebind<_Tp*>::other _Map_alloc_type;
>
> typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
>
> struct _Deque_impl
> : public _Tp_alloc_type
> {
> _Tp** _M_map;
> size_t _M_map_size;
> iterator _M_start;
> iterator _M_finish;
>
> _Deque_impl()
> : _Tp_alloc_type(), _M_map(0), _M_map_size(0),
> _M_start(), _M_finish()
> { }
>
> _Deque_impl(const _Tp_alloc_type& __a)
> : _Tp_alloc_type(__a), _M_map(0), _M_map_size(0),
> _M_start(), _M_finish()
> { }
>
>
> _Deque_impl(_Tp_alloc_type&& __a)
> : _Tp_alloc_type(std::move(__a)), _M_map(0), _M_map_size(0),
> _M_start(), _M_finish()
> { }
>
> };
>
> _Tp_alloc_type&
> _M_get_Tp_allocator() noexcept
> { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
>
> const _Tp_alloc_type&
> _M_get_Tp_allocator() const noexcept
> { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
>
> _Map_alloc_type
> _M_get_map_allocator() const noexcept
> { return _Map_alloc_type(_M_get_Tp_allocator()); }
>
> _Tp*
> _M_allocate_node()
> {
> return _M_impl._Tp_alloc_type::allocate(__deque_buf_size(sizeof(_Tp)));
> }
>
> void
> _M_deallocate_node(_Tp* __p)
> {
> _M_impl._Tp_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp)));
> }
>
> _Tp**
> _M_allocate_map(size_t __n)
> { return _M_get_map_allocator().allocate(__n); }
>
> void
> _M_deallocate_map(_Tp** __p, size_t __n)
> { _M_get_map_allocator().deallocate(__p, __n); }
>
> protected:
> void _M_initialize_map(size_t);
> void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
> void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish);
> enum { _S_initial_map_size = 8 };
>
> _Deque_impl _M_impl;
> };
>
> template<typename _Tp, typename _Alloc>
> _Deque_base<_Tp, _Alloc>::
> ~_Deque_base()
> {
> if (this->_M_impl._M_map)
> {
> _M_destroy_nodes(this->_M_impl._M_start._M_node,
> this->_M_impl._M_finish._M_node + 1);
> _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
> }
> }
># 579 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> template<typename _Tp, typename _Alloc>
> void
> _Deque_base<_Tp, _Alloc>::
> _M_initialize_map(size_t __num_elements)
> {
> const size_t __num_nodes = (__num_elements/ __deque_buf_size(sizeof(_Tp))
> + 1);
>
> this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,
> size_t(__num_nodes + 2));
> this->_M_impl._M_map = _M_allocate_map(this->_M_impl._M_map_size);
>
>
>
>
>
>
> _Tp** __nstart = (this->_M_impl._M_map
> + (this->_M_impl._M_map_size - __num_nodes) / 2);
> _Tp** __nfinish = __nstart + __num_nodes;
>
> try
> { _M_create_nodes(__nstart, __nfinish); }
> catch(...)
> {
> _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
> this->_M_impl._M_map = 0;
> this->_M_impl._M_map_size = 0;
> throw;
> }
>
> this->_M_impl._M_start._M_set_node(__nstart);
> this->_M_impl._M_finish._M_set_node(__nfinish - 1);
> this->_M_impl._M_start._M_cur = _M_impl._M_start._M_first;
> this->_M_impl._M_finish._M_cur = (this->_M_impl._M_finish._M_first
> + __num_elements
> % __deque_buf_size(sizeof(_Tp)));
> }
>
> template<typename _Tp, typename _Alloc>
> void
> _Deque_base<_Tp, _Alloc>::
> _M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
> {
> _Tp** __cur;
> try
> {
> for (__cur = __nstart; __cur < __nfinish; ++__cur)
> *__cur = this->_M_allocate_node();
> }
> catch(...)
> {
> _M_destroy_nodes(__nstart, __cur);
> throw;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> void
> _Deque_base<_Tp, _Alloc>::
> _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish)
> {
> for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
> _M_deallocate_node(*__n);
> }
># 729 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
> class deque : protected _Deque_base<_Tp, _Alloc>
> {
>
> typedef typename _Alloc::value_type _Alloc_value_type;
> 
> 
>
> typedef _Deque_base<_Tp, _Alloc> _Base;
> typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
>
> public:
> typedef _Tp value_type;
> typedef typename _Tp_alloc_type::pointer pointer;
> typedef typename _Tp_alloc_type::const_pointer const_pointer;
> typedef typename _Tp_alloc_type::reference reference;
> typedef typename _Tp_alloc_type::const_reference const_reference;
> typedef typename _Base::iterator iterator;
> typedef typename _Base::const_iterator const_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Alloc allocator_type;
>
> protected:
> typedef pointer* _Map_pointer;
>
> static size_t _S_buffer_size()
> { return __deque_buf_size(sizeof(_Tp)); }
>
>
> using _Base::_M_initialize_map;
> using _Base::_M_create_nodes;
> using _Base::_M_destroy_nodes;
> using _Base::_M_allocate_node;
> using _Base::_M_deallocate_node;
> using _Base::_M_allocate_map;
> using _Base::_M_deallocate_map;
> using _Base::_M_get_Tp_allocator;
>
>
>
>
>
> using _Base::_M_impl;
>
> public:
>
>
>
>
>
> deque()
> : _Base() { }
>
>
>
>
>
> explicit
> deque(const allocator_type& __a)
> : _Base(__a, 0) { }
># 801 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> explicit
> deque(size_type __n)
> : _Base(__n)
> { _M_default_initialize(); }
># 814 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> deque(size_type __n, const value_type& __value,
> const allocator_type& __a = allocator_type())
> : _Base(__a, __n)
> { _M_fill_initialize(__value); }
># 841 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> deque(const deque& __x)
> : _Base(__x._M_get_Tp_allocator(), __x.size())
> { std::__uninitialized_copy_a(__x.begin(), __x.end(),
> this->_M_impl._M_start,
> _M_get_Tp_allocator()); }
># 855 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> deque(deque&& __x)
> : _Base(std::move(__x)) { }
># 869 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> deque(initializer_list<value_type> __l,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> {
> _M_range_initialize(__l.begin(), __l.end(),
> random_access_iterator_tag());
> }
># 894 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> deque(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> { _M_initialize_dispatch(__first, __last, __false_type()); }
># 917 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> ~deque() noexcept
> { _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); }
># 927 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> deque&
> operator=(const deque& __x);
># 938 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> deque&
> operator=(deque&& __x)
> {
>
>
> this->clear();
> this->swap(__x);
> return *this;
> }
># 959 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> deque&
> operator=(initializer_list<value_type> __l)
> {
> this->assign(__l.begin(), __l.end());
> return *this;
> }
># 977 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> void
> assign(size_type __n, const value_type& __val)
> { _M_fill_assign(__n, __val); }
># 994 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> void
> assign(_InputIterator __first, _InputIterator __last)
> { _M_assign_dispatch(__first, __last, __false_type()); }
># 1021 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> void
> assign(initializer_list<value_type> __l)
> { this->assign(__l.begin(), __l.end()); }
>
>
>
> allocator_type
> get_allocator() const noexcept
> { return _Base::get_allocator(); }
>
>
>
>
>
>
> iterator
> begin() noexcept
> { return this->_M_impl._M_start; }
>
>
>
>
>
> const_iterator
> begin() const noexcept
> { return this->_M_impl._M_start; }
>
>
>
>
>
>
> iterator
> end() noexcept
> { return this->_M_impl._M_finish; }
>
>
>
>
>
>
> const_iterator
> end() const noexcept
> { return this->_M_impl._M_finish; }
>
>
>
>
>
>
> reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(this->_M_impl._M_finish); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(this->_M_impl._M_finish); }
>
>
>
>
>
>
> reverse_iterator
> rend() noexcept
> { return reverse_iterator(this->_M_impl._M_start); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(this->_M_impl._M_start); }
>
>
>
>
>
>
> const_iterator
> cbegin() const noexcept
> { return this->_M_impl._M_start; }
>
>
>
>
>
>
> const_iterator
> cend() const noexcept
> { return this->_M_impl._M_finish; }
>
>
>
>
>
>
> const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(this->_M_impl._M_finish); }
>
>
>
>
>
>
> const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(this->_M_impl._M_start); }
>
>
>
>
> size_type
> size() const noexcept
> { return this->_M_impl._M_finish - this->_M_impl._M_start; }
>
>
> size_type
> max_size() const noexcept
> { return _M_get_Tp_allocator().max_size(); }
># 1160 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> void
> resize(size_type __new_size)
> {
> const size_type __len = size();
> if (__new_size > __len)
> _M_default_append(__new_size - __len);
> else if (__new_size < __len)
> _M_erase_at_end(this->_M_impl._M_start
> + difference_type(__new_size));
> }
># 1182 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> void
> resize(size_type __new_size, const value_type& __x)
> {
> const size_type __len = size();
> if (__new_size > __len)
> insert(this->_M_impl._M_finish, __new_size - __len, __x);
> else if (__new_size < __len)
> _M_erase_at_end(this->_M_impl._M_start
> + difference_type(__new_size));
> }
># 1218 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> void
> shrink_to_fit()
> { _M_shrink_to_fit(); }
>
>
>
>
>
>
> bool
> empty() const noexcept
> { return this->_M_impl._M_finish == this->_M_impl._M_start; }
># 1243 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> reference
> operator[](size_type __n)
> { return this->_M_impl._M_start[difference_type(__n)]; }
># 1258 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> const_reference
> operator[](size_type __n) const
> { return this->_M_impl._M_start[difference_type(__n)]; }
>
> protected:
>
> void
> _M_range_check(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range(("deque::_M_range_check"));
> }
>
> public:
># 1283 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> reference
> at(size_type __n)
> {
> _M_range_check(__n);
> return (*this)[__n];
> }
># 1301 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> const_reference
> at(size_type __n) const
> {
> _M_range_check(__n);
> return (*this)[__n];
> }
>
>
>
>
>
> reference
> front()
> { return *begin(); }
>
>
>
>
>
> const_reference
> front() const
> { return *begin(); }
>
>
>
>
>
> reference
> back()
> {
> iterator __tmp = end();
> --__tmp;
> return *__tmp;
> }
>
>
>
>
>
> const_reference
> back() const
> {
> const_iterator __tmp = end();
> --__tmp;
> return *__tmp;
> }
># 1358 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> void
> push_front(const value_type& __x)
> {
> if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
> {
> this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1, __x);
> --this->_M_impl._M_start._M_cur;
> }
> else
> _M_push_front_aux(__x);
> }
>
>
> void
> push_front(value_type&& __x)
> { emplace_front(std::move(__x)); }
>
> template<typename... _Args>
> void
> emplace_front(_Args&&... __args);
># 1389 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> void
> push_back(const value_type& __x)
> {
> if (this->_M_impl._M_finish._M_cur
> != this->_M_impl._M_finish._M_last - 1)
> {
> this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __x);
> ++this->_M_impl._M_finish._M_cur;
> }
> else
> _M_push_back_aux(__x);
> }
>
>
> void
> push_back(value_type&& __x)
> { emplace_back(std::move(__x)); }
>
> template<typename... _Args>
> void
> emplace_back(_Args&&... __args);
># 1420 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> void
> pop_front()
> {
> if (this->_M_impl._M_start._M_cur
> != this->_M_impl._M_start._M_last - 1)
> {
> this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
> ++this->_M_impl._M_start._M_cur;
> }
> else
> _M_pop_front_aux();
> }
># 1441 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> void
> pop_back()
> {
> if (this->_M_impl._M_finish._M_cur
> != this->_M_impl._M_finish._M_first)
> {
> --this->_M_impl._M_finish._M_cur;
> this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
> }
> else
> _M_pop_back_aux();
> }
># 1464 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> template<typename... _Args>
> iterator
> emplace(iterator __position, _Args&&... __args);
># 1478 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> iterator
> insert(iterator __position, const value_type& __x);
># 1491 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> iterator
> insert(iterator __position, value_type&& __x)
> { return emplace(__position, std::move(__x)); }
># 1504 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> void
> insert(iterator __p, initializer_list<value_type> __l)
> { this->insert(__p, __l.begin(), __l.end()); }
># 1518 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> void
> insert(iterator __position, size_type __n, const value_type& __x)
> { _M_fill_insert(__position, __n, __x); }
># 1533 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> void
> insert(iterator __position, _InputIterator __first,
> _InputIterator __last)
> { _M_insert_dispatch(__position, __first, __last, __false_type()); }
># 1564 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> iterator
> erase(iterator __position);
># 1583 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> iterator
> erase(iterator __first, iterator __last);
># 1595 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> void
> swap(deque& __x)
> {
> std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
> std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
> std::swap(this->_M_impl._M_map, __x._M_impl._M_map);
> std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size);
>
>
>
> std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(),
> __x._M_get_Tp_allocator());
> }
>
>
>
>
>
>
>
> void
> clear() noexcept
> { _M_erase_at_end(begin()); }
>
> protected:
>
>
>
>
>
>
> template<typename _Integer>
> void
> _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
> {
> _M_initialize_map(static_cast<size_type>(__n));
> _M_fill_initialize(__x);
> }
>
>
> template<typename _InputIterator>
> void
> _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_range_initialize(__first, __last, _IterCategory());
> }
># 1657 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> template<typename _InputIterator>
> void
> _M_range_initialize(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag);
># 1679 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> void
> _M_fill_initialize(const value_type& __value);
>
>
>
> void
> _M_default_initialize();
># 1695 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> template<typename _Integer>
> void
> _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> { _M_fill_assign(__n, __val); }
>
>
> template<typename _InputIterator>
> void
> _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_assign_aux(__first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __len = std::distance(__first, __last);
> if (__len > size())
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, size());
> std::copy(__first, __mid, begin());
> insert(end(), __mid, __last);
> }
> else
> _M_erase_at_end(std::copy(__first, __last, begin()));
> }
>
>
>
> void
> _M_fill_assign(size_type __n, const value_type& __val)
> {
> if (__n > size())
> {
> std::fill(begin(), end(), __val);
> insert(end(), __n - size(), __val);
> }
> else
> {
> _M_erase_at_end(begin() + difference_type(__n));
> std::fill(begin(), end(), __val);
> }
> }
># 1759 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> template<typename... _Args>
> void _M_push_back_aux(_Args&&... __args);
>
> template<typename... _Args>
> void _M_push_front_aux(_Args&&... __args);
>
>
> void _M_pop_back_aux();
>
> void _M_pop_front_aux();
># 1778 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> template<typename _Integer>
> void
> _M_insert_dispatch(iterator __pos,
> _Integer __n, _Integer __x, __true_type)
> { _M_fill_insert(__pos, __n, __x); }
>
>
> template<typename _InputIterator>
> void
> _M_insert_dispatch(iterator __pos,
> _InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_range_insert_aux(__pos, __first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_range_insert_aux(iterator __pos, _InputIterator __first,
> _InputIterator __last, std::input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_range_insert_aux(iterator __pos, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag);
>
>
>
>
> void
> _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
>
>
>
>
>
>
> template<typename... _Args>
> iterator
> _M_insert_aux(iterator __pos, _Args&&... __args);
>
>
>
> void
> _M_insert_aux(iterator __pos, size_type __n, const value_type& __x);
>
>
> template<typename _ForwardIterator>
> void
> _M_insert_aux(iterator __pos,
> _ForwardIterator __first, _ForwardIterator __last,
> size_type __n);
>
>
>
>
> void
> _M_destroy_data_aux(iterator __first, iterator __last);
>
>
>
> template<typename _Alloc1>
> void
> _M_destroy_data(iterator __first, iterator __last, const _Alloc1&)
> { _M_destroy_data_aux(__first, __last); }
>
> void
> _M_destroy_data(iterator __first, iterator __last,
> const std::allocator<_Tp>&)
> {
> if (!__has_trivial_destructor(value_type))
> _M_destroy_data_aux(__first, __last);
> }
>
>
> void
> _M_erase_at_begin(iterator __pos)
> {
> _M_destroy_data(begin(), __pos, _M_get_Tp_allocator());
> _M_destroy_nodes(this->_M_impl._M_start._M_node, __pos._M_node);
> this->_M_impl._M_start = __pos;
> }
>
>
>
> void
> _M_erase_at_end(iterator __pos)
> {
> _M_destroy_data(__pos, end(), _M_get_Tp_allocator());
> _M_destroy_nodes(__pos._M_node + 1,
> this->_M_impl._M_finish._M_node + 1);
> this->_M_impl._M_finish = __pos;
> }
>
>
>
> void
> _M_default_append(size_type __n);
>
> bool
> _M_shrink_to_fit();
>
>
>
>
> iterator
> _M_reserve_elements_at_front(size_type __n)
> {
> const size_type __vacancies = this->_M_impl._M_start._M_cur
> - this->_M_impl._M_start._M_first;
> if (__n > __vacancies)
> _M_new_elements_at_front(__n - __vacancies);
> return this->_M_impl._M_start - difference_type(__n);
> }
>
> iterator
> _M_reserve_elements_at_back(size_type __n)
> {
> const size_type __vacancies = (this->_M_impl._M_finish._M_last
> - this->_M_impl._M_finish._M_cur) - 1;
> if (__n > __vacancies)
> _M_new_elements_at_back(__n - __vacancies);
> return this->_M_impl._M_finish + difference_type(__n);
> }
>
> void
> _M_new_elements_at_front(size_type __new_elements);
>
> void
> _M_new_elements_at_back(size_type __new_elements);
># 1923 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> void
> _M_reserve_map_at_back(size_type __nodes_to_add = 1)
> {
> if (__nodes_to_add + 1 > this->_M_impl._M_map_size
> - (this->_M_impl._M_finish._M_node - this->_M_impl._M_map))
> _M_reallocate_map(__nodes_to_add, false);
> }
>
> void
> _M_reserve_map_at_front(size_type __nodes_to_add = 1)
> {
> if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node
> - this->_M_impl._M_map))
> _M_reallocate_map(__nodes_to_add, true);
> }
>
> void
> _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);
>
> };
># 1955 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator==(const deque<_Tp, _Alloc>& __x,
> const deque<_Tp, _Alloc>& __y)
> { return __x.size() == __y.size()
> && std::equal(__x.begin(), __x.end(), __y.begin()); }
># 1973 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<(const deque<_Tp, _Alloc>& __x,
> const deque<_Tp, _Alloc>& __y)
> { return std::lexicographical_compare(__x.begin(), __x.end(),
> __y.begin(), __y.end()); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator!=(const deque<_Tp, _Alloc>& __x,
> const deque<_Tp, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>(const deque<_Tp, _Alloc>& __x,
> const deque<_Tp, _Alloc>& __y)
> { return __y < __x; }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<=(const deque<_Tp, _Alloc>& __x,
> const deque<_Tp, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>=(const deque<_Tp, _Alloc>& __x,
> const deque<_Tp, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline void
> swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
> { __x.swap(__y); }
>
>
>
>
>}
># 65 "/usr/include/c++/4.8.2/deque" 2 3
>
># 1 "/usr/include/c++/4.8.2/bits/deque.tcc" 1 3
># 59 "/usr/include/c++/4.8.2/bits/deque.tcc" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_default_initialize()
> {
> _Map_pointer __cur;
> try
> {
> for (__cur = this->_M_impl._M_start._M_node;
> __cur < this->_M_impl._M_finish._M_node;
> ++__cur)
> std::__uninitialized_default_a(*__cur, *__cur + _S_buffer_size(),
> _M_get_Tp_allocator());
> std::__uninitialized_default_a(this->_M_impl._M_finish._M_first,
> this->_M_impl._M_finish._M_cur,
> _M_get_Tp_allocator());
> }
> catch(...)
> {
> std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
> _M_get_Tp_allocator());
> throw;
> }
> }
>
>
> template <typename _Tp, typename _Alloc>
> deque<_Tp, _Alloc>&
> deque<_Tp, _Alloc>::
> operator=(const deque& __x)
> {
> const size_type __len = size();
> if (&__x != this)
> {
> if (__len >= __x.size())
> _M_erase_at_end(std::copy(__x.begin(), __x.end(),
> this->_M_impl._M_start));
> else
> {
> const_iterator __mid = __x.begin() + difference_type(__len);
> std::copy(__x.begin(), __mid, this->_M_impl._M_start);
> insert(this->_M_impl._M_finish, __mid, __x.end());
> }
> }
> return *this;
> }
>
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
> void
> deque<_Tp, _Alloc>::
> emplace_front(_Args&&... __args)
> {
> if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
> {
> this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1,
> std::forward<_Args>(__args)...);
> --this->_M_impl._M_start._M_cur;
> }
> else
> _M_push_front_aux(std::forward<_Args>(__args)...);
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
> void
> deque<_Tp, _Alloc>::
> emplace_back(_Args&&... __args)
> {
> if (this->_M_impl._M_finish._M_cur
> != this->_M_impl._M_finish._M_last - 1)
> {
> this->_M_impl.construct(this->_M_impl._M_finish._M_cur,
> std::forward<_Args>(__args)...);
> ++this->_M_impl._M_finish._M_cur;
> }
> else
> _M_push_back_aux(std::forward<_Args>(__args)...);
> }
>
>
> template <typename _Tp, typename _Alloc>
> typename deque<_Tp, _Alloc>::iterator
> deque<_Tp, _Alloc>::
> insert(iterator __position, const value_type& __x)
> {
> if (__position._M_cur == this->_M_impl._M_start._M_cur)
> {
> push_front(__x);
> return this->_M_impl._M_start;
> }
> else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
> {
> push_back(__x);
> iterator __tmp = this->_M_impl._M_finish;
> --__tmp;
> return __tmp;
> }
> else
> return _M_insert_aux(__position, __x);
> }
>
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
> typename deque<_Tp, _Alloc>::iterator
> deque<_Tp, _Alloc>::
> emplace(iterator __position, _Args&&... __args)
> {
> if (__position._M_cur == this->_M_impl._M_start._M_cur)
> {
> emplace_front(std::forward<_Args>(__args)...);
> return this->_M_impl._M_start;
> }
> else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
> {
> emplace_back(std::forward<_Args>(__args)...);
> iterator __tmp = this->_M_impl._M_finish;
> --__tmp;
> return __tmp;
> }
> else
> return _M_insert_aux(__position, std::forward<_Args>(__args)...);
> }
>
>
> template <typename _Tp, typename _Alloc>
> typename deque<_Tp, _Alloc>::iterator
> deque<_Tp, _Alloc>::
> erase(iterator __position)
> {
> iterator __next = __position;
> ++__next;
> const difference_type __index = __position - begin();
> if (static_cast<size_type>(__index) < (size() >> 1))
> {
> if (__position != begin())
> std::move_backward(begin(), __position, __next);
> pop_front();
> }
> else
> {
> if (__next != end())
> std::move(__next, end(), __position);
> pop_back();
> }
> return begin() + __index;
> }
>
> template <typename _Tp, typename _Alloc>
> typename deque<_Tp, _Alloc>::iterator
> deque<_Tp, _Alloc>::
> erase(iterator __first, iterator __last)
> {
> if (__first == __last)
> return __first;
> else if (__first == begin() && __last == end())
> {
> clear();
> return end();
> }
> else
> {
> const difference_type __n = __last - __first;
> const difference_type __elems_before = __first - begin();
> if (static_cast<size_type>(__elems_before) <= (size() - __n) / 2)
> {
> if (__first != begin())
> std::move_backward(begin(), __first, __last);
> _M_erase_at_begin(begin() + __n);
> }
> else
> {
> if (__last != end())
> std::move(__last, end(), __first);
> _M_erase_at_end(end() - __n);
> }
> return begin() + __elems_before;
> }
> }
>
> template <typename _Tp, class _Alloc>
> template <typename _InputIterator>
> void
> deque<_Tp, _Alloc>::
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> iterator __cur = begin();
> for (; __first != __last && __cur != end(); ++__cur, ++__first)
> *__cur = *__first;
> if (__first == __last)
> _M_erase_at_end(__cur);
> else
> insert(end(), __first, __last);
> }
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
> {
> if (__pos._M_cur == this->_M_impl._M_start._M_cur)
> {
> iterator __new_start = _M_reserve_elements_at_front(__n);
> try
> {
> std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start,
> __x, _M_get_Tp_allocator());
> this->_M_impl._M_start = __new_start;
> }
> catch(...)
> {
> _M_destroy_nodes(__new_start._M_node,
> this->_M_impl._M_start._M_node);
> throw;
> }
> }
> else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
> {
> iterator __new_finish = _M_reserve_elements_at_back(__n);
> try
> {
> std::__uninitialized_fill_a(this->_M_impl._M_finish,
> __new_finish, __x,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = __new_finish;
> }
> catch(...)
> {
> _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
> __new_finish._M_node + 1);
> throw;
> }
> }
> else
> _M_insert_aux(__pos, __n, __x);
> }
>
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_default_append(size_type __n)
> {
> if (__n)
> {
> iterator __new_finish = _M_reserve_elements_at_back(__n);
> try
> {
> std::__uninitialized_default_a(this->_M_impl._M_finish,
> __new_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = __new_finish;
> }
> catch(...)
> {
> _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
> __new_finish._M_node + 1);
> throw;
> }
> }
> }
>
> template <typename _Tp, typename _Alloc>
> bool
> deque<_Tp, _Alloc>::
> _M_shrink_to_fit()
> {
> const difference_type __front_capacity
> = (this->_M_impl._M_start._M_cur - this->_M_impl._M_start._M_first);
> if (__front_capacity == 0)
> return false;
>
> const difference_type __back_capacity
> = (this->_M_impl._M_finish._M_last - this->_M_impl._M_finish._M_cur);
> if (__front_capacity + __back_capacity < _S_buffer_size())
> return false;
>
> return std::__shrink_to_fit_aux<deque>::_S_do_it(*this);
> }
>
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_fill_initialize(const value_type& __value)
> {
> _Map_pointer __cur;
> try
> {
> for (__cur = this->_M_impl._M_start._M_node;
> __cur < this->_M_impl._M_finish._M_node;
> ++__cur)
> std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(),
> __value, _M_get_Tp_allocator());
> std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first,
> this->_M_impl._M_finish._M_cur,
> __value, _M_get_Tp_allocator());
> }
> catch(...)
> {
> std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
> _M_get_Tp_allocator());
> throw;
> }
> }
>
> template <typename _Tp, typename _Alloc>
> template <typename _InputIterator>
> void
> deque<_Tp, _Alloc>::
> _M_range_initialize(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> this->_M_initialize_map(0);
> try
> {
> for (; __first != __last; ++__first)
>
> emplace_back(*__first);
>
>
>
> }
> catch(...)
> {
> clear();
> throw;
> }
> }
>
> template <typename _Tp, typename _Alloc>
> template <typename _ForwardIterator>
> void
> deque<_Tp, _Alloc>::
> _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __n = std::distance(__first, __last);
> this->_M_initialize_map(__n);
>
> _Map_pointer __cur_node;
> try
> {
> for (__cur_node = this->_M_impl._M_start._M_node;
> __cur_node < this->_M_impl._M_finish._M_node;
> ++__cur_node)
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, _S_buffer_size());
> std::__uninitialized_copy_a(__first, __mid, *__cur_node,
> _M_get_Tp_allocator());
> __first = __mid;
> }
> std::__uninitialized_copy_a(__first, __last,
> this->_M_impl._M_finish._M_first,
> _M_get_Tp_allocator());
> }
> catch(...)
> {
> std::_Destroy(this->_M_impl._M_start,
> iterator(*__cur_node, __cur_node),
> _M_get_Tp_allocator());
> throw;
> }
> }
>
>
> template<typename _Tp, typename _Alloc>
>
> template<typename... _Args>
> void
> deque<_Tp, _Alloc>::
> _M_push_back_aux(_Args&&... __args)
>
>
>
>
>
> {
> _M_reserve_map_at_back();
> *(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
> try
> {
>
> this->_M_impl.construct(this->_M_impl._M_finish._M_cur,
> std::forward<_Args>(__args)...);
>
>
>
> this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node
> + 1);
> this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
> }
> catch(...)
> {
> _M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1));
> throw;
> }
> }
>
>
> template<typename _Tp, typename _Alloc>
>
> template<typename... _Args>
> void
> deque<_Tp, _Alloc>::
> _M_push_front_aux(_Args&&... __args)
>
>
>
>
>
> {
> _M_reserve_map_at_front();
> *(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node();
> try
> {
> this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node
> - 1);
> this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1;
>
> this->_M_impl.construct(this->_M_impl._M_start._M_cur,
> std::forward<_Args>(__args)...);
>
>
>
> }
> catch(...)
> {
> ++this->_M_impl._M_start;
> _M_deallocate_node(*(this->_M_impl._M_start._M_node - 1));
> throw;
> }
> }
>
>
> template <typename _Tp, typename _Alloc>
> void deque<_Tp, _Alloc>::
> _M_pop_back_aux()
> {
> _M_deallocate_node(this->_M_impl._M_finish._M_first);
> this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node - 1);
> this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_last - 1;
> this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
> }
>
>
>
>
>
>
> template <typename _Tp, typename _Alloc>
> void deque<_Tp, _Alloc>::
> _M_pop_front_aux()
> {
> this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
> _M_deallocate_node(this->_M_impl._M_start._M_first);
> this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1);
> this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first;
> }
>
> template <typename _Tp, typename _Alloc>
> template <typename _InputIterator>
> void
> deque<_Tp, _Alloc>::
> _M_range_insert_aux(iterator __pos,
> _InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> { std::copy(__first, __last, std::inserter(*this, __pos)); }
>
> template <typename _Tp, typename _Alloc>
> template <typename _ForwardIterator>
> void
> deque<_Tp, _Alloc>::
> _M_range_insert_aux(iterator __pos,
> _ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __n = std::distance(__first, __last);
> if (__pos._M_cur == this->_M_impl._M_start._M_cur)
> {
> iterator __new_start = _M_reserve_elements_at_front(__n);
> try
> {
> std::__uninitialized_copy_a(__first, __last, __new_start,
> _M_get_Tp_allocator());
> this->_M_impl._M_start = __new_start;
> }
> catch(...)
> {
> _M_destroy_nodes(__new_start._M_node,
> this->_M_impl._M_start._M_node);
> throw;
> }
> }
> else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
> {
> iterator __new_finish = _M_reserve_elements_at_back(__n);
> try
> {
> std::__uninitialized_copy_a(__first, __last,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = __new_finish;
> }
> catch(...)
> {
> _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
> __new_finish._M_node + 1);
> throw;
> }
> }
> else
> _M_insert_aux(__pos, __first, __last, __n);
> }
>
> template<typename _Tp, typename _Alloc>
>
> template<typename... _Args>
> typename deque<_Tp, _Alloc>::iterator
> deque<_Tp, _Alloc>::
> _M_insert_aux(iterator __pos, _Args&&... __args)
> {
> value_type __x_copy(std::forward<_Args>(__args)...);
>
>
>
>
>
>
>
> difference_type __index = __pos - this->_M_impl._M_start;
> if (static_cast<size_type>(__index) < size() / 2)
> {
> push_front(std::move(front()));
> iterator __front1 = this->_M_impl._M_start;
> ++__front1;
> iterator __front2 = __front1;
> ++__front2;
> __pos = this->_M_impl._M_start + __index;
> iterator __pos1 = __pos;
> ++__pos1;
> std::move(__front2, __pos1, __front1);
> }
> else
> {
> push_back(std::move(back()));
> iterator __back1 = this->_M_impl._M_finish;
> --__back1;
> iterator __back2 = __back1;
> --__back2;
> __pos = this->_M_impl._M_start + __index;
> std::move_backward(__pos, __back2, __back1);
> }
> *__pos = std::move(__x_copy);
> return __pos;
> }
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_insert_aux(iterator __pos, size_type __n, const value_type& __x)
> {
> const difference_type __elems_before = __pos - this->_M_impl._M_start;
> const size_type __length = this->size();
> value_type __x_copy = __x;
> if (__elems_before < difference_type(__length / 2))
> {
> iterator __new_start = _M_reserve_elements_at_front(__n);
> iterator __old_start = this->_M_impl._M_start;
> __pos = this->_M_impl._M_start + __elems_before;
> try
> {
> if (__elems_before >= difference_type(__n))
> {
> iterator __start_n = (this->_M_impl._M_start
> + difference_type(__n));
> std::__uninitialized_move_a(this->_M_impl._M_start,
> __start_n, __new_start,
> _M_get_Tp_allocator());
> this->_M_impl._M_start = __new_start;
> std::move(__start_n, __pos, __old_start);
> std::fill(__pos - difference_type(__n), __pos, __x_copy);
> }
> else
> {
> std::__uninitialized_move_fill(this->_M_impl._M_start,
> __pos, __new_start,
> this->_M_impl._M_start,
> __x_copy,
> _M_get_Tp_allocator());
> this->_M_impl._M_start = __new_start;
> std::fill(__old_start, __pos, __x_copy);
> }
> }
> catch(...)
> {
> _M_destroy_nodes(__new_start._M_node,
> this->_M_impl._M_start._M_node);
> throw;
> }
> }
> else
> {
> iterator __new_finish = _M_reserve_elements_at_back(__n);
> iterator __old_finish = this->_M_impl._M_finish;
> const difference_type __elems_after =
> difference_type(__length) - __elems_before;
> __pos = this->_M_impl._M_finish - __elems_after;
> try
> {
> if (__elems_after > difference_type(__n))
> {
> iterator __finish_n = (this->_M_impl._M_finish
> - difference_type(__n));
> std::__uninitialized_move_a(__finish_n,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = __new_finish;
> std::move_backward(__pos, __finish_n, __old_finish);
> std::fill(__pos, __pos + difference_type(__n), __x_copy);
> }
> else
> {
> std::__uninitialized_fill_move(this->_M_impl._M_finish,
> __pos + difference_type(__n),
> __x_copy, __pos,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = __new_finish;
> std::fill(__pos, __old_finish, __x_copy);
> }
> }
> catch(...)
> {
> _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
> __new_finish._M_node + 1);
> throw;
> }
> }
> }
>
> template <typename _Tp, typename _Alloc>
> template <typename _ForwardIterator>
> void
> deque<_Tp, _Alloc>::
> _M_insert_aux(iterator __pos,
> _ForwardIterator __first, _ForwardIterator __last,
> size_type __n)
> {
> const difference_type __elemsbefore = __pos - this->_M_impl._M_start;
> const size_type __length = size();
> if (static_cast<size_type>(__elemsbefore) < __length / 2)
> {
> iterator __new_start = _M_reserve_elements_at_front(__n);
> iterator __old_start = this->_M_impl._M_start;
> __pos = this->_M_impl._M_start + __elemsbefore;
> try
> {
> if (__elemsbefore >= difference_type(__n))
> {
> iterator __start_n = (this->_M_impl._M_start
> + difference_type(__n));
> std::__uninitialized_move_a(this->_M_impl._M_start,
> __start_n, __new_start,
> _M_get_Tp_allocator());
> this->_M_impl._M_start = __new_start;
> std::move(__start_n, __pos, __old_start);
> std::copy(__first, __last, __pos - difference_type(__n));
> }
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, difference_type(__n) - __elemsbefore);
> std::__uninitialized_move_copy(this->_M_impl._M_start,
> __pos, __first, __mid,
> __new_start,
> _M_get_Tp_allocator());
> this->_M_impl._M_start = __new_start;
> std::copy(__mid, __last, __old_start);
> }
> }
> catch(...)
> {
> _M_destroy_nodes(__new_start._M_node,
> this->_M_impl._M_start._M_node);
> throw;
> }
> }
> else
> {
> iterator __new_finish = _M_reserve_elements_at_back(__n);
> iterator __old_finish = this->_M_impl._M_finish;
> const difference_type __elemsafter =
> difference_type(__length) - __elemsbefore;
> __pos = this->_M_impl._M_finish - __elemsafter;
> try
> {
> if (__elemsafter > difference_type(__n))
> {
> iterator __finish_n = (this->_M_impl._M_finish
> - difference_type(__n));
> std::__uninitialized_move_a(__finish_n,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = __new_finish;
> std::move_backward(__pos, __finish_n, __old_finish);
> std::copy(__first, __last, __pos);
> }
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, __elemsafter);
> std::__uninitialized_copy_move(__mid, __last, __pos,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = __new_finish;
> std::copy(__first, __mid, __pos);
> }
> }
> catch(...)
> {
> _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
> __new_finish._M_node + 1);
> throw;
> }
> }
> }
>
> template<typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_destroy_data_aux(iterator __first, iterator __last)
> {
> for (_Map_pointer __node = __first._M_node + 1;
> __node < __last._M_node; ++__node)
> std::_Destroy(*__node, *__node + _S_buffer_size(),
> _M_get_Tp_allocator());
>
> if (__first._M_node != __last._M_node)
> {
> std::_Destroy(__first._M_cur, __first._M_last,
> _M_get_Tp_allocator());
> std::_Destroy(__last._M_first, __last._M_cur,
> _M_get_Tp_allocator());
> }
> else
> std::_Destroy(__first._M_cur, __last._M_cur,
> _M_get_Tp_allocator());
> }
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_new_elements_at_front(size_type __new_elems)
> {
> if (this->max_size() - this->size() < __new_elems)
> __throw_length_error(("deque::_M_new_elements_at_front"));
>
> const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
> / _S_buffer_size());
> _M_reserve_map_at_front(__new_nodes);
> size_type __i;
> try
> {
> for (__i = 1; __i <= __new_nodes; ++__i)
> *(this->_M_impl._M_start._M_node - __i) = this->_M_allocate_node();
> }
> catch(...)
> {
> for (size_type __j = 1; __j < __i; ++__j)
> _M_deallocate_node(*(this->_M_impl._M_start._M_node - __j));
> throw;
> }
> }
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_new_elements_at_back(size_type __new_elems)
> {
> if (this->max_size() - this->size() < __new_elems)
> __throw_length_error(("deque::_M_new_elements_at_back"));
>
> const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
> / _S_buffer_size());
> _M_reserve_map_at_back(__new_nodes);
> size_type __i;
> try
> {
> for (__i = 1; __i <= __new_nodes; ++__i)
> *(this->_M_impl._M_finish._M_node + __i) = this->_M_allocate_node();
> }
> catch(...)
> {
> for (size_type __j = 1; __j < __i; ++__j)
> _M_deallocate_node(*(this->_M_impl._M_finish._M_node + __j));
> throw;
> }
> }
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp, _Alloc>::
> _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front)
> {
> const size_type __old_num_nodes
> = this->_M_impl._M_finish._M_node - this->_M_impl._M_start._M_node + 1;
> const size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
>
> _Map_pointer __new_nstart;
> if (this->_M_impl._M_map_size > 2 * __new_num_nodes)
> {
> __new_nstart = this->_M_impl._M_map + (this->_M_impl._M_map_size
> - __new_num_nodes) / 2
> + (__add_at_front ? __nodes_to_add : 0);
> if (__new_nstart < this->_M_impl._M_start._M_node)
> std::copy(this->_M_impl._M_start._M_node,
> this->_M_impl._M_finish._M_node + 1,
> __new_nstart);
> else
> std::copy_backward(this->_M_impl._M_start._M_node,
> this->_M_impl._M_finish._M_node + 1,
> __new_nstart + __old_num_nodes);
> }
> else
> {
> size_type __new_map_size = this->_M_impl._M_map_size
> + std::max(this->_M_impl._M_map_size,
> __nodes_to_add) + 2;
>
> _Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
> __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
> + (__add_at_front ? __nodes_to_add : 0);
> std::copy(this->_M_impl._M_start._M_node,
> this->_M_impl._M_finish._M_node + 1,
> __new_nstart);
> _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
>
> this->_M_impl._M_map = __new_map;
> this->_M_impl._M_map_size = __new_map_size;
> }
>
> this->_M_impl._M_start._M_set_node(__new_nstart);
> this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
> }
>
>
>
> template<typename _Tp>
> void
> fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>& __first,
> const _Deque_iterator<_Tp, _Tp&, _Tp*>& __last, const _Tp& __value)
> {
> typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
>
> for (typename _Self::_Map_pointer __node = __first._M_node + 1;
> __node < __last._M_node; ++__node)
> std::fill(*__node, *__node + _Self::_S_buffer_size(), __value);
>
> if (__first._M_node != __last._M_node)
> {
> std::fill(__first._M_cur, __first._M_last, __value);
> std::fill(__last._M_first, __last._M_cur, __value);
> }
> else
> std::fill(__first._M_cur, __last._M_cur, __value);
> }
>
> template<typename _Tp>
> _Deque_iterator<_Tp, _Tp&, _Tp*>
> copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
> _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
> _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
> {
> typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
> typedef typename _Self::difference_type difference_type;
>
> difference_type __len = __last - __first;
> while (__len > 0)
> {
> const difference_type __clen
> = std::min(__len, std::min(__first._M_last - __first._M_cur,
> __result._M_last - __result._M_cur));
> std::copy(__first._M_cur, __first._M_cur + __clen, __result._M_cur);
> __first += __clen;
> __result += __clen;
> __len -= __clen;
> }
> return __result;
> }
>
> template<typename _Tp>
> _Deque_iterator<_Tp, _Tp&, _Tp*>
> copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
> _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
> _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
> {
> typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
> typedef typename _Self::difference_type difference_type;
>
> difference_type __len = __last - __first;
> while (__len > 0)
> {
> difference_type __llen = __last._M_cur - __last._M_first;
> _Tp* __lend = __last._M_cur;
>
> difference_type __rlen = __result._M_cur - __result._M_first;
> _Tp* __rend = __result._M_cur;
>
> if (!__llen)
> {
> __llen = _Self::_S_buffer_size();
> __lend = *(__last._M_node - 1) + __llen;
> }
> if (!__rlen)
> {
> __rlen = _Self::_S_buffer_size();
> __rend = *(__result._M_node - 1) + __rlen;
> }
>
> const difference_type __clen = std::min(__len,
> std::min(__llen, __rlen));
> std::copy_backward(__lend - __clen, __lend, __rend);
> __last -= __clen;
> __result -= __clen;
> __len -= __clen;
> }
> return __result;
> }
>
>
> template<typename _Tp>
> _Deque_iterator<_Tp, _Tp&, _Tp*>
> move(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
> _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
> _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
> {
> typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
> typedef typename _Self::difference_type difference_type;
>
> difference_type __len = __last - __first;
> while (__len > 0)
> {
> const difference_type __clen
> = std::min(__len, std::min(__first._M_last - __first._M_cur,
> __result._M_last - __result._M_cur));
> std::move(__first._M_cur, __first._M_cur + __clen, __result._M_cur);
> __first += __clen;
> __result += __clen;
> __len -= __clen;
> }
> return __result;
> }
>
> template<typename _Tp>
> _Deque_iterator<_Tp, _Tp&, _Tp*>
> move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
> _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
> _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
> {
> typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
> typedef typename _Self::difference_type difference_type;
>
> difference_type __len = __last - __first;
> while (__len > 0)
> {
> difference_type __llen = __last._M_cur - __last._M_first;
> _Tp* __lend = __last._M_cur;
>
> difference_type __rlen = __result._M_cur - __result._M_first;
> _Tp* __rend = __result._M_cur;
>
> if (!__llen)
> {
> __llen = _Self::_S_buffer_size();
> __lend = *(__last._M_node - 1) + __llen;
> }
> if (!__rlen)
> {
> __rlen = _Self::_S_buffer_size();
> __rend = *(__result._M_node - 1) + __rlen;
> }
>
> const difference_type __clen = std::min(__len,
> std::min(__llen, __rlen));
> std::move_backward(__lend - __clen, __lend, __rend);
> __last -= __clen;
> __result -= __clen;
> __len -= __clen;
> }
> return __result;
> }
>
>
>
>}
># 67 "/usr/include/c++/4.8.2/deque" 2 3
># 27 "/usr/include/boost/circular_buffer/base.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
>
>
># 1 "/usr/include/string.h" 1 3 4
># 27 "/usr/include/string.h" 3 4
>extern "C" {
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 33 "/usr/include/string.h" 2 3 4
>
>
>
>
>
>
>
>
>
>extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
> size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memmove (void *__dest, const void *__src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
> int __c, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int memcmp (const void *__s1, const void *__s2, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern "C++"
>{
>extern void *memchr (void *__s, int __c, size_t __n)
> throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern const void *memchr (const void *__s, int __c, size_t __n)
> throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) void *
>memchr (void *__s, int __c, size_t __n) throw ()
>{
> return __builtin_memchr (__s, __c, __n);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const void *
>memchr (const void *__s, int __c, size_t __n) throw ()
>{
> return __builtin_memchr (__s, __c, __n);
>}
>
>}
>
>
>
>
>
>
>
>
>
>
>extern "C++" void *rawmemchr (void *__s, int __c)
> throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern "C++" const void *rawmemchr (const void *__s, int __c)
> throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern "C++" void *memrchr (void *__s, int __c, size_t __n)
> throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
> throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>
>
>extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncpy (char *__restrict __dest,
> const char *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strcat (char *__restrict __dest, const char *__restrict __src)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncat (char *__restrict __dest, const char *__restrict __src,
> size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcmp (const char *__s1, const char *__s2)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int strncmp (const char *__s1, const char *__s2, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcoll (const char *__s1, const char *__s2)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern size_t strxfrm (char *__restrict __dest,
> const char *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (2)));
>
># 162 "/usr/include/string.h" 3 4
>extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
> __locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
>
>
>
>
>
>extern char *strdup (const char *__s)
> throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *strndup (const char *__string, size_t __n)
> throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
># 207 "/usr/include/string.h" 3 4
>
>
>
>extern "C++"
>{
>extern char *strchr (char *__s, int __c)
> throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern const char *strchr (const char *__s, int __c)
> throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>strchr (char *__s, int __c) throw ()
>{
> return __builtin_strchr (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>strchr (const char *__s, int __c) throw ()
>{
> return __builtin_strchr (__s, __c);
>}
>
>}
>
>
>
>
>
>
>extern "C++"
>{
>extern char *strrchr (char *__s, int __c)
> throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern const char *strrchr (const char *__s, int __c)
> throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>strrchr (char *__s, int __c) throw ()
>{
> return __builtin_strrchr (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>strrchr (const char *__s, int __c) throw ()
>{
> return __builtin_strrchr (__s, __c);
>}
>
>}
>
>
>
>
>
>
>
>
>
>
>extern "C++" char *strchrnul (char *__s, int __c)
> throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern "C++" const char *strchrnul (const char *__s, int __c)
> throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>
>
>extern size_t strcspn (const char *__s, const char *__reject)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern size_t strspn (const char *__s, const char *__accept)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern "C++"
>{
>extern char *strpbrk (char *__s, const char *__accept)
> throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>extern const char *strpbrk (const char *__s, const char *__accept)
> throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>strpbrk (char *__s, const char *__accept) throw ()
>{
> return __builtin_strpbrk (__s, __accept);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>strpbrk (const char *__s, const char *__accept) throw ()
>{
> return __builtin_strpbrk (__s, __accept);
>}
>
>}
>
>
>
>
>
>
>extern "C++"
>{
>extern char *strstr (char *__haystack, const char *__needle)
> throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>extern const char *strstr (const char *__haystack, const char *__needle)
> throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>strstr (char *__haystack, const char *__needle) throw ()
>{
> return __builtin_strstr (__haystack, __needle);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>strstr (const char *__haystack, const char *__needle) throw ()
>{
> return __builtin_strstr (__haystack, __needle);
>}
>
>}
>
>
>
>
>
>
>
>extern char *strtok (char *__restrict __s, const char *__restrict __delim)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern char *__strtok_r (char *__restrict __s,
> const char *__restrict __delim,
> char **__restrict __save_ptr)
> throw () __attribute__ ((__nonnull__ (2, 3)));
>
>extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
> char **__restrict __save_ptr)
> throw () __attribute__ ((__nonnull__ (2, 3)));
>
>
>
>
>
>extern "C++" char *strcasestr (char *__haystack, const char *__needle)
> throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>extern "C++" const char *strcasestr (const char *__haystack,
> const char *__needle)
> throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 378 "/usr/include/string.h" 3 4
>extern void *memmem (const void *__haystack, size_t __haystacklen,
> const void *__needle, size_t __needlelen)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern void *__mempcpy (void *__restrict __dest,
> const void *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>extern void *mempcpy (void *__restrict __dest,
> const void *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern size_t strlen (const char *__s)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern size_t strnlen (const char *__string, size_t __maxlen)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern char *strerror (int __errnum) throw ();
>
># 434 "/usr/include/string.h" 3 4
>extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
> throw () __attribute__ ((__nonnull__ (2))) ;
>
>
>
>
>
>extern char *strerror_l (int __errnum, __locale_t __l) throw ();
>
>
>
>
>
>extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern void bcopy (const void *__src, void *__dest, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int bcmp (const void *__s1, const void *__s2, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern "C++"
>{
>extern char *index (char *__s, int __c)
> throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern const char *index (const char *__s, int __c)
> throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>index (char *__s, int __c) throw ()
>{
> return __builtin_index (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>index (const char *__s, int __c) throw ()
>{
> return __builtin_index (__s, __c);
>}
>
>}
>
>
>
>
>
>
>
>extern "C++"
>{
>extern char *rindex (char *__s, int __c)
> throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern const char *rindex (const char *__s, int __c)
> throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>rindex (char *__s, int __c) throw ()
>{
> return __builtin_rindex (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>rindex (const char *__s, int __c) throw ()
>{
> return __builtin_rindex (__s, __c);
>}
>
>}
>
>
>
>
>
>
>
>extern int ffs (int __i) throw () __attribute__ ((__const__));
>
>
>
>
>extern int ffsl (long int __l) throw () __attribute__ ((__const__));
>__extension__ extern int ffsll (long long int __ll)
> throw () __attribute__ ((__const__));
>
>
>
>extern int strcasecmp (const char *__s1, const char *__s2)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int strcasecmp_l (const char *__s1, const char *__s2,
> __locale_t __loc)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>extern int strncasecmp_l (const char *__s1, const char *__s2,
> size_t __n, __locale_t __loc)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
>
>
>
>
>
>extern char *strsep (char **__restrict __stringp,
> const char *__restrict __delim)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern char *strsignal (int __sig) throw ();
>
>
>extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern char *__stpncpy (char *__restrict __dest,
> const char *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpncpy (char *__restrict __dest,
> const char *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int strverscmp (const char *__s1, const char *__s2)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern "C++" char *basename (char *__filename)
> throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
>extern "C++" const char *basename (const char *__filename)
> throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
># 640 "/usr/include/string.h" 3 4
>}
># 43 "/usr/include/c++/4.8.2/cstring" 2 3
># 71 "/usr/include/c++/4.8.2/cstring" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> using ::memchr;
> using ::memcmp;
> using ::memcpy;
> using ::memmove;
> using ::memset;
> using ::strcat;
> using ::strcmp;
> using ::strcoll;
> using ::strcpy;
> using ::strcspn;
> using ::strerror;
> using ::strlen;
> using ::strncat;
> using ::strncmp;
> using ::strncpy;
> using ::strspn;
> using ::strtok;
> using ::strxfrm;
> using ::strchr;
> using ::strpbrk;
> using ::strrchr;
> using ::strstr;
># 120 "/usr/include/c++/4.8.2/cstring" 3
>
>}
># 32 "/usr/include/boost/circular_buffer/base.hpp" 2 3 4
># 43 "/usr/include/boost/circular_buffer/base.hpp" 3 4
>namespace boost {
># 69 "/usr/include/boost/circular_buffer/base.hpp" 3 4
>template <class T, class Alloc>
>class circular_buffer
>
>
>: public cb_details::debug_iterator_registry
>
>
>{
>
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::SGIAssignableConcept<T>)>::failed> boost_concept_check79 __attribute__((unused));
>
>public:
>
>
>
> typedef typename Alloc::value_type value_type;
>
>
> typedef typename Alloc::pointer pointer;
>
>
> typedef typename Alloc::const_pointer const_pointer;
>
>
> typedef typename Alloc::reference reference;
>
>
> typedef typename Alloc::const_reference const_reference;
>
>
>
>
>
> typedef typename Alloc::difference_type difference_type;
>
>
>
>
>
> typedef typename Alloc::size_type size_type;
>
>
> typedef Alloc allocator_type;
>
>
>
>
> typedef cb_details::iterator< circular_buffer<T, Alloc>, cb_details::const_traits<Alloc> > const_iterator;
>
>
> typedef cb_details::iterator< circular_buffer<T, Alloc>, cb_details::nonconst_traits<Alloc> > iterator;
>
>
> typedef boost::reverse_iterator<const_iterator> const_reverse_iterator;
>
>
> typedef boost::reverse_iterator<iterator> reverse_iterator;
># 136 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> typedef std::pair<pointer, size_type> array_range;
>
>
>
>
>
>
>
> typedef std::pair<const_pointer, size_type> const_array_range;
>
>
>
>
>
>
> typedef size_type capacity_type;
>
>
>
>
> typedef typename call_traits<value_type>::param_type param_value_type;
>
>
> typedef typename call_traits<value_type>::param_type return_value_type;
>
>private:
>
>
>
> pointer m_buff;
>
>
> pointer m_end;
>
>
> pointer m_first;
>
>
> pointer m_last;
>
>
> size_type m_size;
>
>
> allocator_type m_alloc;
>
>
>
>
>
>
> template <class Buff, class Traits> friend struct cb_details::iterator;
>
>
>public:
># 205 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> allocator_type get_allocator() const { return m_alloc; }
># 221 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> allocator_type& get_allocator() { return m_alloc; }
># 239 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> iterator begin() { return iterator(this, empty() ? 0 : m_first); }
># 255 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> iterator end() { return iterator(this, 0); }
># 271 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> const_iterator begin() const { return const_iterator(this, empty() ? 0 : m_first); }
># 287 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> const_iterator end() const { return const_iterator(this, 0); }
># 303 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> reverse_iterator rbegin() { return reverse_iterator(end()); }
># 319 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> reverse_iterator rend() { return reverse_iterator(begin()); }
># 335 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
># 351 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
># 367 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> reference operator [] (size_type index) {
> ((index < size()) ? static_cast<void> (0) : __assert_fail ("index < size()", "/usr/include/boost/circular_buffer/base.hpp", 368, __PRETTY_FUNCTION__));
> return *add(m_first, index);
> }
># 386 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> return_value_type operator [] (size_type index) const {
> ((index < size()) ? static_cast<void> (0) : __assert_fail ("index < size()", "/usr/include/boost/circular_buffer/base.hpp", 387, __PRETTY_FUNCTION__));
> return *add(m_first, index);
> }
># 405 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> reference at(size_type index) {
> check_position(index);
> return (*this)[index];
> }
># 424 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> return_value_type at(size_type index) const {
> check_position(index);
> return (*this)[index];
> }
># 442 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> reference front() {
> ((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()", "/usr/include/boost/circular_buffer/base.hpp", 443, __PRETTY_FUNCTION__));
> return *m_first;
> }
># 460 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> reference back() {
> ((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()", "/usr/include/boost/circular_buffer/base.hpp", 461, __PRETTY_FUNCTION__));
> return *((m_last == m_buff ? m_end : m_last) - 1);
> }
># 478 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> return_value_type front() const {
> ((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()", "/usr/include/boost/circular_buffer/base.hpp", 479, __PRETTY_FUNCTION__));
> return *m_first;
> }
># 496 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> return_value_type back() const {
> ((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()", "/usr/include/boost/circular_buffer/base.hpp", 497, __PRETTY_FUNCTION__));
> return *((m_last == m_buff ? m_end : m_last) - 1);
> }
># 546 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> array_range array_one() {
> return array_range(m_first, (m_last <= m_first && !empty() ? m_end : m_last) - m_first);
> }
># 566 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> array_range array_two() {
> return array_range(m_buff, m_last <= m_first && !empty() ? m_last - m_buff : 0);
> }
># 586 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> const_array_range array_one() const {
> return const_array_range(m_first, (m_last <= m_first && !empty() ? m_end : m_last) - m_first);
> }
># 606 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> const_array_range array_two() const {
> return const_array_range(m_buff, m_last <= m_first && !empty() ? m_last - m_buff : 0);
> }
># 631 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> pointer linearize() {
> if (empty())
> return 0;
> if (m_first < m_last || m_last == m_buff)
> return m_first;
> pointer src = m_first;
> pointer dest = m_buff;
> size_type moved = 0;
> size_type constructed = 0;
> { try {
> for (pointer first = m_first; dest < src; src = first) {
> for (size_type ii = 0; src < m_end; ++src, ++dest, ++moved, ++ii) {
> if (moved == size()) {
> first = dest;
> break;
> }
> if (dest == first) {
> first += ii;
> break;
> }
> if (is_uninitialized(dest)) {
> m_alloc.construct(dest, *src);
> ++constructed;
> } else {
> value_type tmp = *src;
> replace(src, *dest);
> replace(dest, tmp);
> }
> }
> }
> } catch(...) {
> m_last += constructed;
> m_size += constructed;
> throw;
> }
> }
> for (src = m_end - constructed; src < m_end; ++src)
> destroy_item(src);
> m_first = m_buff;
> m_last = add(m_buff, size());
>
> invalidate_iterators_except(end());
>
> return m_buff;
> }
># 692 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> bool is_linearized() const { return m_first < m_last || m_last == m_buff; }
># 722 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void rotate(const_iterator new_begin) {
> ((new_begin.is_valid(this)) ? static_cast<void> (0) : __assert_fail ("new_begin.is_valid(this)", "/usr/include/boost/circular_buffer/base.hpp", 723, __PRETTY_FUNCTION__));
> ((new_begin.m_it != 0) ? static_cast<void> (0) : __assert_fail ("new_begin.m_it != 0", "/usr/include/boost/circular_buffer/base.hpp", 724, __PRETTY_FUNCTION__));
> if (full()) {
> m_first = m_last = const_cast<pointer>(new_begin.m_it);
> } else {
> difference_type m = end() - new_begin;
> difference_type n = new_begin - begin();
> if (m < n) {
> for (; m > 0; --m) {
> push_front(back());
> pop_back();
> }
> } else {
> for (; n > 0; --n) {
> push_back(front());
> pop_front();
> }
> }
> }
> }
># 759 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> size_type size() const { return m_size; }
># 773 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> size_type max_size() const {
> return (std::min<size_type>)(m_alloc.max_size(), (std::numeric_limits<difference_type>::max)());
> }
># 790 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> bool empty() const { return size() == 0; }
># 805 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> bool full() const { return capacity() == size(); }
># 819 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> size_type reserve() const { return capacity() - size(); }
># 834 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> capacity_type capacity() const { return m_end - m_buff; }
># 856 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void set_capacity(capacity_type new_capacity) {
> if (new_capacity == capacity())
> return;
> pointer buff = allocate(new_capacity);
> iterator b = begin();
> { try {
> reset(buff,
> cb_details::uninitialized_copy_with_alloc(b, b + (std::min)(new_capacity, size()), buff, m_alloc),
> new_capacity);
> } catch(...) {
> deallocate(buff, new_capacity);
> throw;
> }
> }
> }
># 899 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void resize(size_type new_size, param_value_type item = value_type()) {
> if (new_size > size()) {
> if (new_size > capacity())
> set_capacity(new_size);
> insert(end(), new_size - size(), item);
> } else {
> iterator e = end();
> erase(e - (size() - new_size), e);
> }
> }
># 930 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void rset_capacity(capacity_type new_capacity) {
> if (new_capacity == capacity())
> return;
> pointer buff = allocate(new_capacity);
> iterator e = end();
> { try {
> reset(buff, cb_details::uninitialized_copy_with_alloc(e - (std::min)(new_capacity, size()),
> e, buff, m_alloc), new_capacity);
> } catch(...) {
> deallocate(buff, new_capacity);
> throw;
> }
> }
> }
># 972 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void rresize(size_type new_size, param_value_type item = value_type()) {
> if (new_size > size()) {
> if (new_size > capacity())
> set_capacity(new_size);
> rinsert(begin(), new_size - size(), item);
> } else {
> rerase(begin(), end() - new_size);
> }
> }
># 1003 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> explicit circular_buffer(const allocator_type& alloc = allocator_type())
> : m_buff(0), m_end(0), m_first(0), m_last(0), m_size(0), m_alloc(alloc) {}
># 1016 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> explicit circular_buffer(capacity_type buffer_capacity, const allocator_type& alloc = allocator_type())
> : m_size(0), m_alloc(alloc) {
> initialize_buffer(buffer_capacity);
> m_first = m_last = m_buff;
> }
># 1035 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> circular_buffer(size_type n, param_value_type item, const allocator_type& alloc = allocator_type())
> : m_size(n), m_alloc(alloc) {
> initialize_buffer(n, item);
> m_first = m_last = m_buff;
> }
># 1056 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> circular_buffer(capacity_type buffer_capacity, size_type n, param_value_type item,
> const allocator_type& alloc = allocator_type())
> : m_size(n), m_alloc(alloc) {
> ((buffer_capacity >= size()) ? static_cast<void> (0) : __assert_fail ("buffer_capacity >= size()", "/usr/include/boost/circular_buffer/base.hpp", 1059, __PRETTY_FUNCTION__));
> initialize_buffer(buffer_capacity, item);
> m_first = m_buff;
> m_last = buffer_capacity == n ? m_buff : m_buff + n;
> }
># 1076 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> circular_buffer(const circular_buffer<T, Alloc>& cb)
> :
>
> debug_iterator_registry(),
>
> m_size(cb.size()), m_alloc(cb.get_allocator()) {
> initialize_buffer(cb.capacity());
> m_first = m_buff;
> { try {
> m_last = cb_details::uninitialized_copy_with_alloc(cb.begin(), cb.end(), m_buff, m_alloc);
> } catch(...) {
> deallocate(m_buff, cb.capacity());
> throw;
> }
> }
> if (m_last == m_end)
> m_last = m_buff;
> }
># 1129 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> template <class InputIterator>
> circular_buffer(InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type())
> : m_alloc(alloc) {
> initialize(first, last, is_integral<InputIterator>());
> }
># 1158 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> template <class InputIterator>
> circular_buffer(capacity_type buffer_capacity, InputIterator first, InputIterator last,
> const allocator_type& alloc = allocator_type())
> : m_alloc(alloc) {
> initialize(buffer_capacity, first, last, is_integral<InputIterator>());
> }
># 1178 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> ~circular_buffer() {
> destroy();
>
> invalidate_all_iterators();
>
> }
>
>public:
># 1209 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> circular_buffer<T, Alloc>& operator = (const circular_buffer<T, Alloc>& cb) {
> if (this == &cb)
> return *this;
> pointer buff = allocate(cb.capacity());
> { try {
> reset(buff, cb_details::uninitialized_copy_with_alloc(cb.begin(), cb.end(), buff, m_alloc), cb.capacity());
> } catch(...) {
> deallocate(buff, cb.capacity());
> throw;
> }
> }
> return *this;
> }
># 1247 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void assign(size_type n, param_value_type item) {
> assign_n(n, n, cb_details::assign_n<param_value_type, allocator_type>(n, item, m_alloc));
> }
># 1276 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void assign(capacity_type buffer_capacity, size_type n, param_value_type item) {
> ((buffer_capacity >= n) ? static_cast<void> (0) : __assert_fail ("buffer_capacity >= n", "/usr/include/boost/circular_buffer/base.hpp", 1277, __PRETTY_FUNCTION__));
> assign_n(buffer_capacity, n, cb_details::assign_n<param_value_type, allocator_type>(n, item, m_alloc));
> }
># 1309 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> template <class InputIterator>
> void assign(InputIterator first, InputIterator last) {
> assign(first, last, is_integral<InputIterator>());
> }
># 1348 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> template <class InputIterator>
> void assign(capacity_type buffer_capacity, InputIterator first, InputIterator last) {
> assign(buffer_capacity, first, last, is_integral<InputIterator>());
> }
># 1370 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void swap(circular_buffer<T, Alloc>& cb) {
> swap_allocator(cb, is_stateless<allocator_type>());
> std::swap(m_buff, cb.m_buff);
> std::swap(m_end, cb.m_end);
> std::swap(m_first, cb.m_first);
> std::swap(m_last, cb.m_last);
> std::swap(m_size, cb.m_size);
>
> invalidate_all_iterators();
> cb.invalidate_all_iterators();
>
> }
># 1402 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void push_back(param_value_type item = value_type()) {
> if (full()) {
> if (empty())
> return;
> replace(m_last, item);
> increment(m_last);
> m_first = m_last;
> } else {
> m_alloc.construct(m_last, item);
> increment(m_last);
> ++m_size;
> }
> }
># 1433 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void push_front(param_value_type item = value_type()) {
> { try {
> if (full()) {
> if (empty())
> return;
> decrement(m_first);
> replace(m_first, item);
> m_last = m_first;
> } else {
> decrement(m_first);
> m_alloc.construct(m_first, item);
> ++m_size;
> }
> } catch(...) {
> increment(m_first);
> throw;
> }
> }
> }
># 1467 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void pop_back() {
> ((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()", "/usr/include/boost/circular_buffer/base.hpp", 1468, __PRETTY_FUNCTION__));
> decrement(m_last);
> destroy_item(m_last);
> --m_size;
> }
># 1488 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void pop_front() {
> ((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()", "/usr/include/boost/circular_buffer/base.hpp", 1489, __PRETTY_FUNCTION__));
> destroy_item(m_first);
> increment(m_first);
> --m_size;
> }
>
>public:
># 1527 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> iterator insert(iterator pos, param_value_type item = value_type()) {
> ((pos.is_valid(this)) ? static_cast<void> (0) : __assert_fail ("pos.is_valid(this)", "/usr/include/boost/circular_buffer/base.hpp", 1528, __PRETTY_FUNCTION__));
> iterator b = begin();
> if (full() && pos == b)
> return b;
> return insert_item(pos, item);
> }
># 1572 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void insert(iterator pos, size_type n, param_value_type item) {
> ((pos.is_valid(this)) ? static_cast<void> (0) : __assert_fail ("pos.is_valid(this)", "/usr/include/boost/circular_buffer/base.hpp", 1573, __PRETTY_FUNCTION__));
> if (n == 0)
> return;
> size_type copy = capacity() - (end() - pos);
> if (copy == 0)
> return;
> if (n > copy)
> n = copy;
> insert_n(pos, n, cb_details::item_wrapper<const_pointer, param_value_type>(item));
> }
># 1628 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> template <class InputIterator>
> void insert(iterator pos, InputIterator first, InputIterator last) {
> ((pos.is_valid(this)) ? static_cast<void> (0) : __assert_fail ("pos.is_valid(this)", "/usr/include/boost/circular_buffer/base.hpp", 1630, __PRETTY_FUNCTION__));
> insert(pos, first, last, is_integral<InputIterator>());
> }
># 1662 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> iterator rinsert(iterator pos, param_value_type item = value_type()) {
> ((pos.is_valid(this)) ? static_cast<void> (0) : __assert_fail ("pos.is_valid(this)", "/usr/include/boost/circular_buffer/base.hpp", 1663, __PRETTY_FUNCTION__));
> if (full() && pos.m_it == 0)
> return end();
> if (pos == begin()) {
> { try {
> decrement(m_first);
> construct_or_replace(!full(), m_first, item);
> } catch(...) {
> increment(m_first);
> throw;
> }
> }
> pos.m_it = m_first;
> } else {
> pointer src = m_first;
> pointer dest = m_first;
> decrement(dest);
> pos.m_it = map_pointer(pos.m_it);
> bool construct = !full();
> { try {
> while (src != pos.m_it) {
> construct_or_replace(construct, dest, *src);
> increment(src);
> increment(dest);
> construct = false;
> }
> decrement(pos.m_it);
> replace(pos.m_it, item);
> } catch(...) {
> if (!construct && !full()) {
> decrement(m_first);
> ++m_size;
> }
> throw;
> }
> }
> decrement(m_first);
> }
> if (full())
> m_last = m_first;
> else
> ++m_size;
> return iterator(this, pos.m_it);
> }
># 1744 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void rinsert(iterator pos, size_type n, param_value_type item) {
> ((pos.is_valid(this)) ? static_cast<void> (0) : __assert_fail ("pos.is_valid(this)", "/usr/include/boost/circular_buffer/base.hpp", 1745, __PRETTY_FUNCTION__));
> rinsert_n(pos, n, cb_details::item_wrapper<const_pointer, param_value_type>(item));
> }
># 1792 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> template <class InputIterator>
> void rinsert(iterator pos, InputIterator first, InputIterator last) {
> ((pos.is_valid(this)) ? static_cast<void> (0) : __assert_fail ("pos.is_valid(this)", "/usr/include/boost/circular_buffer/base.hpp", 1794, __PRETTY_FUNCTION__));
> rinsert(pos, first, last, is_integral<InputIterator>());
> }
># 1820 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> iterator erase(iterator pos) {
> ((pos.is_valid(this)) ? static_cast<void> (0) : __assert_fail ("pos.is_valid(this)", "/usr/include/boost/circular_buffer/base.hpp", 1821, __PRETTY_FUNCTION__));
> ((pos.m_it != 0) ? static_cast<void> (0) : __assert_fail ("pos.m_it != 0", "/usr/include/boost/circular_buffer/base.hpp", 1822, __PRETTY_FUNCTION__));
> pointer next = pos.m_it;
> increment(next);
> for (pointer p = pos.m_it; next != m_last; p = next, increment(next))
> replace(p, *next);
> decrement(m_last);
> destroy_item(m_last);
> --m_size;
>
> return m_last == pos.m_it ? end() : iterator(this, pos.m_it);
>
>
>
> }
># 1857 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> iterator erase(iterator first, iterator last) {
> ((first.is_valid(this)) ? static_cast<void> (0) : __assert_fail ("first.is_valid(this)", "/usr/include/boost/circular_buffer/base.hpp", 1858, __PRETTY_FUNCTION__));
> ((last.is_valid(this)) ? static_cast<void> (0) : __assert_fail ("last.is_valid(this)", "/usr/include/boost/circular_buffer/base.hpp", 1859, __PRETTY_FUNCTION__));
> ((first <= last) ? static_cast<void> (0) : __assert_fail ("first <= last", "/usr/include/boost/circular_buffer/base.hpp", 1860, __PRETTY_FUNCTION__));
> if (first == last)
> return first;
> pointer p = first.m_it;
> while (last.m_it != 0)
> replace((first++).m_it, *last++);
> do {
> decrement(m_last);
> destroy_item(m_last);
> --m_size;
> } while(m_last != first.m_it);
> return m_last == p ? end() : iterator(this, p);
> }
># 1897 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> iterator rerase(iterator pos) {
> ((pos.is_valid(this)) ? static_cast<void> (0) : __assert_fail ("pos.is_valid(this)", "/usr/include/boost/circular_buffer/base.hpp", 1898, __PRETTY_FUNCTION__));
> ((pos.m_it != 0) ? static_cast<void> (0) : __assert_fail ("pos.m_it != 0", "/usr/include/boost/circular_buffer/base.hpp", 1899, __PRETTY_FUNCTION__));
> pointer prev = pos.m_it;
> pointer p = prev;
> for (decrement(prev); p != m_first; p = prev, decrement(prev))
> replace(p, *prev);
> destroy_item(m_first);
> increment(m_first);
> --m_size;
>
> return p == pos.m_it ? begin() : iterator(this, pos.m_it);
>
>
>
> }
># 1937 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> iterator rerase(iterator first, iterator last) {
> ((first.is_valid(this)) ? static_cast<void> (0) : __assert_fail ("first.is_valid(this)", "/usr/include/boost/circular_buffer/base.hpp", 1938, __PRETTY_FUNCTION__));
> ((last.is_valid(this)) ? static_cast<void> (0) : __assert_fail ("last.is_valid(this)", "/usr/include/boost/circular_buffer/base.hpp", 1939, __PRETTY_FUNCTION__));
> ((first <= last) ? static_cast<void> (0) : __assert_fail ("first <= last", "/usr/include/boost/circular_buffer/base.hpp", 1940, __PRETTY_FUNCTION__));
> if (first == last)
> return first;
> pointer p = map_pointer(last.m_it);
> last.m_it = p;
> while (first.m_it != m_first) {
> decrement(first.m_it);
> decrement(p);
> replace(p, *first.m_it);
> }
> do {
> destroy_item(m_first);
> increment(m_first);
> --m_size;
> } while(m_first != p);
> if (m_first == last.m_it)
> return begin();
> decrement(last.m_it);
> return iterator(this, last.m_it);
> }
># 1984 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void erase_begin(size_type n) {
> ((n <= size()) ? static_cast<void> (0) : __assert_fail ("n <= size()", "/usr/include/boost/circular_buffer/base.hpp", 1985, __PRETTY_FUNCTION__));
>
> erase_begin(n, false_type());
>
>
>
> }
># 2016 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void erase_end(size_type n) {
> ((n <= size()) ? static_cast<void> (0) : __assert_fail ("n <= size()", "/usr/include/boost/circular_buffer/base.hpp", 2017, __PRETTY_FUNCTION__));
>
> erase_end(n, false_type());
>
>
>
> }
># 2040 "/usr/include/boost/circular_buffer/base.hpp" 3 4
> void clear() {
> destroy_content();
> m_size = 0;
> }
>
>private:
>
>
>
> void check_position(size_type index) const {
> if (index >= size())
> throw_exception(std::out_of_range("circular_buffer"));
> }
>
>
> template <class Pointer>
> void increment(Pointer& p) const {
> if (++p == m_end)
> p = m_buff;
> }
>
>
> template <class Pointer>
> void decrement(Pointer& p) const {
> if (p == m_buff)
> p = m_end;
> --p;
> }
>
>
> template <class Pointer>
> Pointer add(Pointer p, difference_type n) const {
> return p + (n < (m_end - p) ? n : n - capacity());
> }
>
>
> template <class Pointer>
> Pointer sub(Pointer p, difference_type n) const {
> return p - (n > (p - m_buff) ? n - capacity() : n);
> }
>
>
> pointer map_pointer(pointer p) const { return p == 0 ? m_last : p; }
>
>
> pointer allocate(size_type n) {
> if (n > max_size())
> throw_exception(std::length_error("circular_buffer"));
>
> pointer p = (n == 0) ? 0 : m_alloc.allocate(n, 0);
> std::memset(p, cb_details::UNINITIALIZED, sizeof(value_type) * n);
> return p;
>
>
>
> }
>
>
> void deallocate(pointer p, size_type n) {
> if (p != 0)
> m_alloc.deallocate(p, n);
> }
>
>
> bool is_uninitialized(const_pointer p) const {
> return p >= m_last && (m_first < m_last || p < m_first);
> }
>
>
> void replace(pointer pos, param_value_type item) {
> *pos = item;
>
> invalidate_iterators(iterator(this, pos));
>
> }
>
>
>
>
>
>
> void construct_or_replace(bool construct, pointer pos, param_value_type item) {
> if (construct)
> m_alloc.construct(pos, item);
> else
> replace(pos, item);
> }
>
>
> void destroy_item(pointer p) {
> m_alloc.destroy(p);
>
> invalidate_iterators(iterator(this, p));
> std::memset(p, cb_details::UNINITIALIZED, sizeof(value_type));
>
> }
>
>
> void destroy_if_constructed(pointer pos) {
> if (is_uninitialized(pos))
> destroy_item(pos);
> }
>
>
> void destroy_content() {
>
> destroy_content(false_type());
>
>
>
> }
>
>
> void destroy_content(const true_type&) {
> m_first = add(m_first, size());
> }
>
>
> void destroy_content(const false_type&) {
> for (size_type ii = 0; ii < size(); ++ii, increment(m_first))
> destroy_item(m_first);
> }
>
>
> void destroy() {
> destroy_content();
> deallocate(m_buff, capacity());
>
> m_buff = 0;
> m_first = 0;
> m_last = 0;
> m_end = 0;
>
> }
>
>
> void initialize_buffer(capacity_type buffer_capacity) {
> m_buff = allocate(buffer_capacity);
> m_end = m_buff + buffer_capacity;
> }
>
>
> void initialize_buffer(capacity_type buffer_capacity, param_value_type item) {
> initialize_buffer(buffer_capacity);
> { try {
> cb_details::uninitialized_fill_n_with_alloc(m_buff, size(), item, m_alloc);
> } catch(...) {
> deallocate(m_buff, size());
> throw;
> }
> }
> }
>
>
> template <class IntegralType>
> void initialize(IntegralType n, IntegralType item, const true_type&) {
> m_size = static_cast<size_type>(n);
> initialize_buffer(size(), item);
> m_first = m_last = m_buff;
> }
>
>
> template <class Iterator>
> void initialize(Iterator first, Iterator last, const false_type&) {
> static_assert((is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value), "(is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value)");
>
>
>
> initialize(first, last, typename iterator_category<Iterator>::type());
>
> }
>
>
> template <class InputIterator>
> void initialize(InputIterator first, InputIterator last, const std::input_iterator_tag&) {
> ((void)0);
>
> std::deque<value_type, allocator_type> tmp(first, last, m_alloc);
> size_type distance = tmp.size();
> initialize(distance, tmp.begin(), tmp.end(), distance);
> }
>
>
> template <class ForwardIterator>
> void initialize(ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) {
> ((std::distance(first, last) >= 0) ? static_cast<void> (0) : __assert_fail ("std::distance(first, last) >= 0", "/usr/include/boost/circular_buffer/base.hpp", 2225, __PRETTY_FUNCTION__));
> size_type distance = std::distance(first, last);
> initialize(distance, first, last, distance);
> }
>
>
> template <class IntegralType>
> void initialize(capacity_type buffer_capacity, IntegralType n, IntegralType item, const true_type&) {
> ((buffer_capacity >= static_cast<size_type>(n)) ? static_cast<void> (0) : __assert_fail ("buffer_capacity >= static_cast<size_type>(n)", "/usr/include/boost/circular_buffer/base.hpp", 2233, __PRETTY_FUNCTION__));
> m_size = static_cast<size_type>(n);
> initialize_buffer(buffer_capacity, item);
> m_first = m_buff;
> m_last = buffer_capacity == size() ? m_buff : m_buff + size();
> }
>
>
> template <class Iterator>
> void initialize(capacity_type buffer_capacity, Iterator first, Iterator last, const false_type&) {
> static_assert((is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value), "(is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value)");
>
>
>
> initialize(buffer_capacity, first, last, typename iterator_category<Iterator>::type());
>
> }
>
>
> template <class InputIterator>
> void initialize(capacity_type buffer_capacity,
> InputIterator first,
> InputIterator last,
> const std::input_iterator_tag&) {
> initialize_buffer(buffer_capacity);
> m_first = m_last = m_buff;
> m_size = 0;
> if (buffer_capacity == 0)
> return;
> while (first != last && !full()) {
> m_alloc.construct(m_last, *first++);
> increment(m_last);
> ++m_size;
> }
> while (first != last) {
> replace(m_last, *first++);
> increment(m_last);
> m_first = m_last;
> }
> }
>
>
> template <class ForwardIterator>
> void initialize(capacity_type buffer_capacity,
> ForwardIterator first,
> ForwardIterator last,
> const std::forward_iterator_tag&) {
> ((std::distance(first, last) >= 0) ? static_cast<void> (0) : __assert_fail ("std::distance(first, last) >= 0", "/usr/include/boost/circular_buffer/base.hpp", 2280, __PRETTY_FUNCTION__));
> initialize(buffer_capacity, first, last, std::distance(first, last));
> }
>
>
> template <class ForwardIterator>
> void initialize(capacity_type buffer_capacity,
> ForwardIterator first,
> ForwardIterator last,
> size_type distance) {
> initialize_buffer(buffer_capacity);
> m_first = m_buff;
> if (distance > buffer_capacity) {
> std::advance(first, distance - buffer_capacity);
> m_size = buffer_capacity;
> } else {
> m_size = distance;
> }
> { try {
> m_last = cb_details::uninitialized_copy_with_alloc(first, last, m_buff, m_alloc);
> } catch(...) {
> deallocate(m_buff, buffer_capacity);
> throw;
> }
> }
> if (m_last == m_end)
> m_last = m_buff;
> }
>
>
> void reset(pointer buff, pointer last, capacity_type new_capacity) {
> destroy();
> m_size = last - buff;
> m_first = m_buff = buff;
> m_end = m_buff + new_capacity;
> m_last = last == m_end ? m_buff : last;
> }
>
>
> void swap_allocator(circular_buffer<T, Alloc>&, const true_type&) {
>
> }
>
>
> void swap_allocator(circular_buffer<T, Alloc>& cb, const false_type&) {
> std::swap(m_alloc, cb.m_alloc);
> }
>
>
> template <class IntegralType>
> void assign(IntegralType n, IntegralType item, const true_type&) {
> assign(static_cast<size_type>(n), static_cast<value_type>(item));
> }
>
>
> template <class Iterator>
> void assign(Iterator first, Iterator last, const false_type&) {
> static_assert((is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value), "(is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value)");
>
>
>
> assign(first, last, typename iterator_category<Iterator>::type());
>
> }
>
>
> template <class InputIterator>
> void assign(InputIterator first, InputIterator last, const std::input_iterator_tag&) {
> ((void)0);
>
> std::deque<value_type, allocator_type> tmp(first, last, m_alloc);
> size_type distance = tmp.size();
> assign_n(distance, distance,
> cb_details::assign_range<typename std::deque<value_type, allocator_type>::iterator,
> allocator_type>(tmp.begin(), tmp.end(), m_alloc));
> }
>
>
> template <class ForwardIterator>
> void assign(ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) {
> ((std::distance(first, last) >= 0) ? static_cast<void> (0) : __assert_fail ("std::distance(first, last) >= 0", "/usr/include/boost/circular_buffer/base.hpp", 2360, __PRETTY_FUNCTION__));
> size_type distance = std::distance(first, last);
> assign_n(distance, distance, cb_details::assign_range<ForwardIterator, allocator_type>(first, last, m_alloc));
> }
>
>
> template <class IntegralType>
> void assign(capacity_type new_capacity, IntegralType n, IntegralType item, const true_type&) {
> assign(new_capacity, static_cast<size_type>(n), static_cast<value_type>(item));
> }
>
>
> template <class Iterator>
> void assign(capacity_type new_capacity, Iterator first, Iterator last, const false_type&) {
> static_assert((is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value), "(is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value)");
>
>
>
> assign(new_capacity, first, last, typename iterator_category<Iterator>::type());
>
> }
>
>
> template <class InputIterator>
> void assign(capacity_type new_capacity, InputIterator first, InputIterator last, const std::input_iterator_tag&) {
> if (new_capacity == capacity()) {
> clear();
> insert(begin(), first, last);
> } else {
>
>
>
>
> circular_buffer<value_type, allocator_type> tmp(new_capacity, first, last, m_alloc);
>
> tmp.swap(*this);
> }
> }
>
>
> template <class ForwardIterator>
> void assign(capacity_type new_capacity, ForwardIterator first, ForwardIterator last,
> const std::forward_iterator_tag&) {
> ((std::distance(first, last) >= 0) ? static_cast<void> (0) : __assert_fail ("std::distance(first, last) >= 0", "/usr/include/boost/circular_buffer/base.hpp", 2403, __PRETTY_FUNCTION__));
> size_type distance = std::distance(first, last);
> if (distance > new_capacity) {
> std::advance(first, distance - new_capacity);
> distance = new_capacity;
> }
> assign_n(new_capacity, distance,
> cb_details::assign_range<ForwardIterator, allocator_type>(first, last, m_alloc));
> }
>
>
> template <class Functor>
> void assign_n(capacity_type new_capacity, size_type n, const Functor& fnc) {
> if (new_capacity == capacity()) {
> destroy_content();
> { try {
> fnc(m_buff);
> } catch(...) {
> m_size = 0;
> throw;
> }
> }
> } else {
> pointer buff = allocate(new_capacity);
> { try {
> fnc(buff);
> } catch(...) {
> deallocate(buff, new_capacity);
> throw;
> }
> }
> destroy();
> m_buff = buff;
> m_end = m_buff + new_capacity;
> }
> m_size = n;
> m_first = m_buff;
> m_last = add(m_buff, size());
> }
>
>
> iterator insert_item(const iterator& pos, param_value_type item) {
> pointer p = pos.m_it;
> if (p == 0) {
> construct_or_replace(!full(), m_last, item);
> p = m_last;
> } else {
> pointer src = m_last;
> pointer dest = m_last;
> bool construct = !full();
> { try {
> while (src != p) {
> decrement(src);
> construct_or_replace(construct, dest, *src);
> decrement(dest);
> construct = false;
> }
> replace(p, item);
> } catch(...) {
> if (!construct && !full()) {
> increment(m_last);
> ++m_size;
> }
> throw;
> }
> }
> }
> increment(m_last);
> if (full())
> m_first = m_last;
> else
> ++m_size;
> return iterator(this, p);
> }
>
>
> template <class IntegralType>
> void insert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
> insert(pos, static_cast<size_type>(n), static_cast<value_type>(item));
> }
>
>
> template <class Iterator>
> void insert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
> static_assert((is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value), "(is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value)");
>
>
>
> insert(pos, first, last, typename iterator_category<Iterator>::type());
>
> }
>
>
> template <class InputIterator>
> void insert(iterator pos, InputIterator first, InputIterator last, const std::input_iterator_tag&) {
> if (!full() || pos != begin()) {
> for (;first != last; ++pos)
> pos = insert_item(pos, *first++);
> }
> }
>
>
> template <class ForwardIterator>
> void insert(const iterator& pos, ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) {
> ((std::distance(first, last) >= 0) ? static_cast<void> (0) : __assert_fail ("std::distance(first, last) >= 0", "/usr/include/boost/circular_buffer/base.hpp", 2507, __PRETTY_FUNCTION__));
> size_type n = std::distance(first, last);
> if (n == 0)
> return;
> size_type copy = capacity() - (end() - pos);
> if (copy == 0)
> return;
> if (n > copy) {
> std::advance(first, n - copy);
> n = copy;
> }
> insert_n(pos, n, cb_details::iterator_wrapper<ForwardIterator>(first));
> }
>
>
> template <class Wrapper>
> void insert_n(const iterator& pos, size_type n, const Wrapper& wrapper) {
> size_type construct = reserve();
> if (construct > n)
> construct = n;
> if (pos.m_it == 0) {
> size_type ii = 0;
> pointer p = m_last;
> { try {
> for (; ii < construct; ++ii, increment(p))
> m_alloc.construct(p, *wrapper());
> for (;ii < n; ++ii, increment(p))
> replace(p, *wrapper());
> } catch(...) {
> size_type constructed = (std::min)(ii, construct);
> m_last = add(m_last, constructed);
> m_size += constructed;
> throw;
> }
> }
> } else {
> pointer src = m_last;
> pointer dest = add(m_last, n - 1);
> pointer p = pos.m_it;
> size_type ii = 0;
> { try {
> while (src != pos.m_it) {
> decrement(src);
> construct_or_replace(is_uninitialized(dest), dest, *src);
> decrement(dest);
> }
> for (; ii < n; ++ii, increment(p))
> construct_or_replace(is_uninitialized(p), p, *wrapper());
> } catch(...) {
> for (p = add(m_last, n - 1); p != dest; decrement(p))
> destroy_if_constructed(p);
> for (n = 0, p = pos.m_it; n < ii; ++n, increment(p))
> destroy_if_constructed(p);
> throw;
> }
> }
> }
> m_last = add(m_last, n);
> m_first = add(m_first, n - construct);
> m_size += construct;
> }
>
>
> template <class IntegralType>
> void rinsert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
> rinsert(pos, static_cast<size_type>(n), static_cast<value_type>(item));
> }
>
>
> template <class Iterator>
> void rinsert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
> static_assert((is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value), "(is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value)");
>
>
>
> rinsert(pos, first, last, typename iterator_category<Iterator>::type());
>
> }
>
>
> template <class InputIterator>
> void rinsert(iterator pos, InputIterator first, InputIterator last, const std::input_iterator_tag&) {
> if (!full() || pos.m_it != 0) {
> for (;first != last; ++pos) {
> pos = rinsert(pos, *first++);
> if (pos.m_it == 0)
> break;
> }
> }
> }
>
>
> template <class ForwardIterator>
> void rinsert(const iterator& pos, ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) {
> ((std::distance(first, last) >= 0) ? static_cast<void> (0) : __assert_fail ("std::distance(first, last) >= 0", "/usr/include/boost/circular_buffer/base.hpp", 2601, __PRETTY_FUNCTION__));
> rinsert_n(pos, std::distance(first, last), cb_details::iterator_wrapper<ForwardIterator>(first));
> }
>
>
> template <class Wrapper>
> void rinsert_n(const iterator& pos, size_type n, const Wrapper& wrapper) {
> if (n == 0)
> return;
> iterator b = begin();
> size_type copy = capacity() - (pos - b);
> if (copy == 0)
> return;
> if (n > copy)
> n = copy;
> size_type construct = reserve();
> if (construct > n)
> construct = n;
> if (pos == b) {
> pointer p = sub(m_first, n);
> size_type ii = n;
> { try {
> for (;ii > construct; --ii, increment(p))
> replace(p, *wrapper());
> for (; ii > 0; --ii, increment(p))
> m_alloc.construct(p, *wrapper());
> } catch(...) {
> size_type constructed = ii < construct ? construct - ii : 0;
> m_last = add(m_last, constructed);
> m_size += constructed;
> throw;
> }
> }
> } else {
> pointer src = m_first;
> pointer dest = sub(m_first, n);
> pointer p = map_pointer(pos.m_it);
> { try {
> while (src != p) {
> construct_or_replace(is_uninitialized(dest), dest, *src);
> increment(src);
> increment(dest);
> }
> for (size_type ii = 0; ii < n; ++ii, increment(dest))
> construct_or_replace(is_uninitialized(dest), dest, *wrapper());
> } catch(...) {
> for (src = sub(m_first, n); src != dest; increment(src))
> destroy_if_constructed(src);
> throw;
> }
> }
> }
> m_first = sub(m_first, n);
> m_last = sub(m_last, n - construct);
> m_size += construct;
> }
>
>
> void erase_begin(size_type n, const true_type&) {
> m_first = add(m_first, n);
> m_size -= n;
> }
>
>
> void erase_begin(size_type n, const false_type&) {
> iterator b = begin();
> rerase(b, b + n);
> }
>
>
> void erase_end(size_type n, const true_type&) {
> m_last = sub(m_last, n);
> m_size -= n;
> }
>
>
> void erase_end(size_type n, const false_type&) {
> iterator e = end();
> erase(e - n, e);
> }
>};
># 2699 "/usr/include/boost/circular_buffer/base.hpp" 3 4
>template <class T, class Alloc>
>inline bool operator == (const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs) {
> return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());
>}
># 2719 "/usr/include/boost/circular_buffer/base.hpp" 3 4
>template <class T, class Alloc>
>inline bool operator < (const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs) {
> return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
>}
># 2738 "/usr/include/boost/circular_buffer/base.hpp" 3 4
>template <class T, class Alloc>
>inline bool operator != (const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs) {
> return !(lhs == rhs);
>}
># 2756 "/usr/include/boost/circular_buffer/base.hpp" 3 4
>template <class T, class Alloc>
>inline bool operator > (const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs) {
> return rhs < lhs;
>}
># 2774 "/usr/include/boost/circular_buffer/base.hpp" 3 4
>template <class T, class Alloc>
>inline bool operator <= (const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs) {
> return !(rhs < lhs);
>}
># 2792 "/usr/include/boost/circular_buffer/base.hpp" 3 4
>template <class T, class Alloc>
>inline bool operator >= (const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs) {
> return !(lhs < rhs);
>}
># 2812 "/usr/include/boost/circular_buffer/base.hpp" 3 4
>template <class T, class Alloc>
>inline void swap(circular_buffer<T, Alloc>& lhs, circular_buffer<T, Alloc>& rhs) {
> lhs.swap(rhs);
>}
>
>
>
>}
># 66 "/usr/include/boost/circular_buffer.hpp" 2 3 4
># 1 "/usr/include/boost/circular_buffer/space_optimized.hpp" 1 3 4
># 19 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
>namespace boost {
># 28 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
>template <class T, class Alloc>
>class circular_buffer_space_optimized :
>
>
>public
>
>
>circular_buffer<T, Alloc> {
>public:
>
>
> typedef typename circular_buffer<T, Alloc>::value_type value_type;
> typedef typename circular_buffer<T, Alloc>::pointer pointer;
> typedef typename circular_buffer<T, Alloc>::const_pointer const_pointer;
> typedef typename circular_buffer<T, Alloc>::reference reference;
> typedef typename circular_buffer<T, Alloc>::const_reference const_reference;
> typedef typename circular_buffer<T, Alloc>::size_type size_type;
> typedef typename circular_buffer<T, Alloc>::difference_type difference_type;
> typedef typename circular_buffer<T, Alloc>::allocator_type allocator_type;
> typedef typename circular_buffer<T, Alloc>::const_iterator const_iterator;
> typedef typename circular_buffer<T, Alloc>::iterator iterator;
> typedef typename circular_buffer<T, Alloc>::const_reverse_iterator const_reverse_iterator;
> typedef typename circular_buffer<T, Alloc>::reverse_iterator reverse_iterator;
> typedef typename circular_buffer<T, Alloc>::array_range array_range;
> typedef typename circular_buffer<T, Alloc>::const_array_range const_array_range;
> typedef typename circular_buffer<T, Alloc>::param_value_type param_value_type;
> typedef typename circular_buffer<T, Alloc>::return_value_type return_value_type;
># 78 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> typedef cb_details::capacity_control<size_type> capacity_type;
>
>
>
> using circular_buffer<T, Alloc>::get_allocator;
> using circular_buffer<T, Alloc>::begin;
> using circular_buffer<T, Alloc>::end;
> using circular_buffer<T, Alloc>::rbegin;
> using circular_buffer<T, Alloc>::rend;
> using circular_buffer<T, Alloc>::at;
> using circular_buffer<T, Alloc>::front;
> using circular_buffer<T, Alloc>::back;
> using circular_buffer<T, Alloc>::array_one;
> using circular_buffer<T, Alloc>::array_two;
> using circular_buffer<T, Alloc>::linearize;
> using circular_buffer<T, Alloc>::is_linearized;
> using circular_buffer<T, Alloc>::rotate;
> using circular_buffer<T, Alloc>::size;
> using circular_buffer<T, Alloc>::max_size;
> using circular_buffer<T, Alloc>::empty;
>
>
>
>
>
> using circular_buffer<T, Alloc>::operator[];
>
>
>private:
>
>
>
> capacity_type m_capacity_ctrl;
>
>public:
># 128 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> bool full() const { return m_capacity_ctrl == size(); }
># 142 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> size_type reserve() const { return m_capacity_ctrl - size(); }
># 158 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> const capacity_type& capacity() const { return m_capacity_ctrl; }
># 200 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> void set_capacity(const capacity_type& capacity_ctrl) {
> m_capacity_ctrl = capacity_ctrl;
> if (capacity_ctrl < size()) {
> iterator e = end();
> circular_buffer<T, Alloc>::erase(e - (size() - capacity_ctrl), e);
> }
> adjust_min_capacity();
> }
># 236 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> void resize(size_type new_size, param_value_type item = value_type()) {
> if (new_size > size()) {
> if (new_size > m_capacity_ctrl)
> m_capacity_ctrl = capacity_type(new_size, m_capacity_ctrl.min_capacity());
> insert(end(), new_size - size(), item);
> } else {
> iterator e = end();
> erase(e - (size() - new_size), e);
> }
> }
># 271 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> void rset_capacity(const capacity_type& capacity_ctrl) {
> m_capacity_ctrl = capacity_ctrl;
> if (capacity_ctrl < size()) {
> iterator b = begin();
> circular_buffer<T, Alloc>::rerase(b, b + (size() - capacity_ctrl));
> }
> adjust_min_capacity();
> }
># 307 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> void rresize(size_type new_size, param_value_type item = value_type()) {
> if (new_size > size()) {
> if (new_size > m_capacity_ctrl)
> m_capacity_ctrl = capacity_type(new_size, m_capacity_ctrl.min_capacity());
> rinsert(begin(), new_size - size(), item);
> } else {
> rerase(begin(), end() - new_size);
> }
> }
># 327 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> explicit circular_buffer_space_optimized(const allocator_type& alloc = allocator_type())
> : circular_buffer<T, Alloc>(0, alloc)
> , m_capacity_ctrl(0) {}
># 344 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> explicit circular_buffer_space_optimized(capacity_type capacity_ctrl,
> const allocator_type& alloc = allocator_type())
> : circular_buffer<T, Alloc>(capacity_ctrl.min_capacity(), alloc)
> , m_capacity_ctrl(capacity_ctrl) {}
># 365 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> circular_buffer_space_optimized(capacity_type capacity_ctrl, param_value_type item,
> const allocator_type& alloc = allocator_type())
> : circular_buffer<T, Alloc>(capacity_ctrl.capacity(), item, alloc)
> , m_capacity_ctrl(capacity_ctrl) {}
># 389 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> circular_buffer_space_optimized(capacity_type capacity_ctrl, size_type n, param_value_type item,
> const allocator_type& alloc = allocator_type())
> : circular_buffer<T, Alloc>(init_capacity(capacity_ctrl, n), n, item, alloc)
> , m_capacity_ctrl(capacity_ctrl) {}
># 431 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> circular_buffer_space_optimized(const circular_buffer_space_optimized<T, Alloc>& cb)
> : circular_buffer<T, Alloc>(cb.begin(), cb.end(), cb.get_allocator())
> , m_capacity_ctrl(cb.m_capacity_ctrl) {}
># 453 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> template <class InputIterator>
> circular_buffer_space_optimized(InputIterator first, InputIterator last,
> const allocator_type& alloc = allocator_type())
> : circular_buffer<T, Alloc>(first, last, alloc)
> , m_capacity_ctrl(circular_buffer<T, Alloc>::capacity()) {}
># 486 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> template <class InputIterator>
> circular_buffer_space_optimized(capacity_type capacity_ctrl, InputIterator first, InputIterator last,
> const allocator_type& alloc = allocator_type())
> : circular_buffer<T, Alloc>(
> init_capacity(capacity_ctrl, first, last, is_integral<InputIterator>()),
> first, last, alloc)
> , m_capacity_ctrl(capacity_ctrl) {
> reduce_capacity(
> is_same< typename iterator_category<InputIterator>::type, std::input_iterator_tag >());
> }
># 547 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> circular_buffer_space_optimized<T, Alloc>& operator = (const circular_buffer_space_optimized<T, Alloc>& cb) {
> if (this == &cb)
> return *this;
> circular_buffer<T, Alloc>::assign(cb.begin(), cb.end());
> m_capacity_ctrl = cb.m_capacity_ctrl;
> return *this;
> }
># 580 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> void assign(size_type n, param_value_type item) {
> circular_buffer<T, Alloc>::assign(n, item);
> m_capacity_ctrl = capacity_type(n);
> }
># 612 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> void assign(capacity_type capacity_ctrl, size_type n, param_value_type item) {
> ((capacity_ctrl.capacity() >= n) ? static_cast<void> (0) : __assert_fail ("capacity_ctrl.capacity() >= n", "/usr/include/boost/circular_buffer/space_optimized.hpp", 613, __PRETTY_FUNCTION__));
> circular_buffer<T, Alloc>::assign((std::max)(capacity_ctrl.min_capacity(), n), n, item);
> m_capacity_ctrl = capacity_ctrl;
> }
># 647 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> template <class InputIterator>
> void assign(InputIterator first, InputIterator last) {
> circular_buffer<T, Alloc>::assign(first, last);
> m_capacity_ctrl = capacity_type(circular_buffer<T, Alloc>::capacity());
> }
># 689 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> template <class InputIterator>
> void assign(capacity_type capacity_ctrl, InputIterator first, InputIterator last) {
> m_capacity_ctrl = capacity_ctrl;
> circular_buffer<T, Alloc>::assign(capacity_ctrl, first, last);
> }
># 714 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> void swap(circular_buffer_space_optimized<T, Alloc>& cb) {
> std::swap(m_capacity_ctrl, cb.m_capacity_ctrl);
> circular_buffer<T, Alloc>::swap(cb);
> }
># 739 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> void push_back(param_value_type item = value_type()) {
> check_low_capacity();
> circular_buffer<T, Alloc>::push_back(item);
> }
># 764 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> void push_front(param_value_type item = value_type()) {
> check_low_capacity();
> circular_buffer<T, Alloc>::push_front(item);
> }
># 786 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> void pop_back() {
> circular_buffer<T, Alloc>::pop_back();
> check_high_capacity();
> }
># 808 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> void pop_front() {
> circular_buffer<T, Alloc>::pop_front();
> check_high_capacity();
> }
># 846 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> iterator insert(iterator pos, param_value_type item = value_type()) {
> size_type index = pos - begin();
> check_low_capacity();
> return circular_buffer<T, Alloc>::insert(begin() + index, item);
> }
># 892 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> void insert(iterator pos, size_type n, param_value_type item) {
> size_type index = pos - begin();
> check_low_capacity(n);
> circular_buffer<T, Alloc>::insert(begin() + index, n, item);
> }
># 944 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> template <class InputIterator>
> void insert(iterator pos, InputIterator first, InputIterator last) {
> insert(pos, first, last, is_integral<InputIterator>());
> }
># 982 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> iterator rinsert(iterator pos, param_value_type item = value_type()) {
> size_type index = pos - begin();
> check_low_capacity();
> return circular_buffer<T, Alloc>::rinsert(begin() + index, item);
> }
># 1028 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> void rinsert(iterator pos, size_type n, param_value_type item) {
> size_type index = pos - begin();
> check_low_capacity(n);
> circular_buffer<T, Alloc>::rinsert(begin() + index, n, item);
> }
># 1081 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> template <class InputIterator>
> void rinsert(iterator pos, InputIterator first, InputIterator last) {
> rinsert(pos, first, last, is_integral<InputIterator>());
> }
># 1108 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> iterator erase(iterator pos) {
> iterator it = circular_buffer<T, Alloc>::erase(pos);
> size_type index = it - begin();
> check_high_capacity();
> return begin() + index;
> }
># 1138 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> iterator erase(iterator first, iterator last) {
> iterator it = circular_buffer<T, Alloc>::erase(first, last);
> size_type index = it - begin();
> check_high_capacity();
> return begin() + index;
> }
># 1169 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> iterator rerase(iterator pos) {
> iterator it = circular_buffer<T, Alloc>::rerase(pos);
> size_type index = it - begin();
> check_high_capacity();
> return begin() + index;
> }
># 1202 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> iterator rerase(iterator first, iterator last) {
> iterator it = circular_buffer<T, Alloc>::rerase(first, last);
> size_type index = it - begin();
> check_high_capacity();
> return begin() + index;
> }
># 1226 "/usr/include/boost/circular_buffer/space_optimized.hpp" 3 4
> void clear() { erase(begin(), end()); }
>
>private:
>
>
>
> void adjust_min_capacity() {
> if (m_capacity_ctrl.min_capacity() > circular_buffer<T, Alloc>::capacity())
> circular_buffer<T, Alloc>::set_capacity(m_capacity_ctrl.min_capacity());
> else
> check_high_capacity();
> }
>
>
> size_type ensure_reserve(size_type new_capacity, size_type buffer_size) const {
> if (buffer_size + new_capacity / 5 >= new_capacity)
> new_capacity *= 2;
> if (new_capacity > m_capacity_ctrl)
> return m_capacity_ctrl;
> return new_capacity;
> }
>
>
>
>
>
> void check_low_capacity(size_type n = 1) {
> size_type new_size = size() + n;
> size_type new_capacity = circular_buffer<T, Alloc>::capacity();
> if (new_size > new_capacity) {
> if (new_capacity == 0)
> new_capacity = 1;
> for (; new_size > new_capacity; new_capacity *= 2) {}
> circular_buffer<T, Alloc>::set_capacity(
> ensure_reserve(new_capacity, new_size));
> }
>
> this->invalidate_iterators_except(end());
>
> }
>
>
>
>
>
> void check_high_capacity() {
> size_type new_capacity = circular_buffer<T, Alloc>::capacity();
> while (new_capacity / 3 >= size()) {
> new_capacity /= 2;
> if (new_capacity <= m_capacity_ctrl.min_capacity()) {
> new_capacity = m_capacity_ctrl.min_capacity();
> break;
> }
> }
> circular_buffer<T, Alloc>::set_capacity(
> ensure_reserve(new_capacity, size()));
>
> this->invalidate_iterators_except(end());
>
> }
>
>
> void reduce_capacity(const true_type&) {
> circular_buffer<T, Alloc>::set_capacity((std::max)(m_capacity_ctrl.min_capacity(), size()));
> }
>
>
> void reduce_capacity(const false_type&) {}
>
>
> static size_type init_capacity(const capacity_type& capacity_ctrl, size_type n) {
> ((capacity_ctrl.capacity() >= n) ? static_cast<void> (0) : __assert_fail ("capacity_ctrl.capacity() >= n", "/usr/include/boost/circular_buffer/space_optimized.hpp", 1297, __PRETTY_FUNCTION__));
> return (std::max)(capacity_ctrl.min_capacity(), n);
> }
>
>
> template <class IntegralType>
> static size_type init_capacity(const capacity_type& capacity_ctrl, IntegralType n, IntegralType,
> const true_type&) {
> return init_capacity(capacity_ctrl, static_cast<size_type>(n));
> }
>
>
> template <class Iterator>
> static size_type init_capacity(const capacity_type& capacity_ctrl, Iterator first, Iterator last,
> const false_type&) {
> static_assert((is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value), "(is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value)");
>
>
>
> return init_capacity(
> capacity_ctrl, first, last, typename iterator_category<Iterator>::type());
>
> }
>
>
> template <class InputIterator>
> static size_type init_capacity(const capacity_type& capacity_ctrl, InputIterator, InputIterator,
> const std::input_iterator_tag&) {
> return capacity_ctrl.capacity();
> }
>
>
> template <class ForwardIterator>
> static size_type init_capacity(const capacity_type& capacity_ctrl, ForwardIterator first, ForwardIterator last,
> const std::forward_iterator_tag&) {
> ((std::distance(first, last) >= 0) ? static_cast<void> (0) : __assert_fail ("std::distance(first, last) >= 0", "/usr/include/boost/circular_buffer/space_optimized.hpp", 1332, __PRETTY_FUNCTION__));
> return (std::max)(capacity_ctrl.min_capacity(),
> (std::min)(capacity_ctrl.capacity(), static_cast<size_type>(std::distance(first, last))));
> }
>
>
> template <class IntegralType>
> void insert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
> insert(pos, static_cast<size_type>(n), static_cast<value_type>(item));
> }
>
>
> template <class Iterator>
> void insert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
> size_type index = pos - begin();
> check_low_capacity(std::distance(first, last));
> circular_buffer<T, Alloc>::insert(begin() + index, first, last);
> }
>
>
> template <class IntegralType>
> void rinsert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
> rinsert(pos, static_cast<size_type>(n), static_cast<value_type>(item));
> }
>
>
> template <class Iterator>
> void rinsert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
> size_type index = pos - begin();
> check_low_capacity(std::distance(first, last));
> circular_buffer<T, Alloc>::rinsert(begin() + index, first, last);
> }
>};
>
>
>
>
>template <class T, class Alloc>
>inline bool operator == (const circular_buffer_space_optimized<T, Alloc>& lhs,
> const circular_buffer_space_optimized<T, Alloc>& rhs) {
> return lhs.size() == rhs.size() &&
> std::equal(lhs.begin(), lhs.end(), rhs.begin());
>}
>
>
>template <class T, class Alloc>
>inline bool operator < (const circular_buffer_space_optimized<T, Alloc>& lhs,
> const circular_buffer_space_optimized<T, Alloc>& rhs) {
> return std::lexicographical_compare(
> lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
>}
>
>
>
>
>template <class T, class Alloc>
>inline bool operator != (const circular_buffer_space_optimized<T, Alloc>& lhs,
> const circular_buffer_space_optimized<T, Alloc>& rhs) {
> return !(lhs == rhs);
>}
>
>
>template <class T, class Alloc>
>inline bool operator > (const circular_buffer_space_optimized<T, Alloc>& lhs,
> const circular_buffer_space_optimized<T, Alloc>& rhs) {
> return rhs < lhs;
>}
>
>
>template <class T, class Alloc>
>inline bool operator <= (const circular_buffer_space_optimized<T, Alloc>& lhs,
> const circular_buffer_space_optimized<T, Alloc>& rhs) {
> return !(rhs < lhs);
>}
>
>
>template <class T, class Alloc>
>inline bool operator >= (const circular_buffer_space_optimized<T, Alloc>& lhs,
> const circular_buffer_space_optimized<T, Alloc>& rhs) {
> return !(lhs < rhs);
>}
>
>
>template <class T, class Alloc>
>inline void swap(circular_buffer_space_optimized<T, Alloc>& lhs,
> circular_buffer_space_optimized<T, Alloc>& rhs) {
> lhs.swap(rhs);
>}
>
>
>
>}
># 67 "/usr/include/boost/circular_buffer.hpp" 2 3 4
># 24 "../src/wildfire.h" 2
># 1 "../src/iWCC.h" 1
># 18 "../src/iWCC.h"
># 1 "/usr/include/errno.h" 1 3 4
># 19 "../src/iWCC.h" 2
>
># 1 "../src/wildfire.h" 1
># 21 "../src/iWCC.h" 2
>
>namespace iwf
>{
># 33 "../src/iWCC.h"
> enum boardType : uint8_t
> {
> beagleBoard = 0,
> iWCC_m = 1,
> iWMC_m = 2,
> iWSS_m = 3,
> iWCC_u = 4,
> iWMC_u = 5,
> iWSS_u = 6,
> iWMC_h = 7,
> iWMC_v = 8,
> iWMC_uh = 9,
> iWMC_uv = 10,
> badBoard
> };
>
> const uint32_t maxBoardName = 11;
> const uint32_t boardNameCount = badBoard;
> extern const char *boardNames[];
> extern const char *boardAliases[];
> boardType boardNameToType(std::string *name);
>
> const uint32_t U_IDsize = 12;
>
>
>
> enum channels
> {
> detectorChannel = 0,
> DCchannel,
> VinHighChannel,
> VinLowChannel,
> V5HighChannel,
> V5lowChannel,
> VDDhighChannel,
> VDDlowChannel,
> IoutChannel,
> VoutChannel,
> VbiasChannel
> };
>
> const float emitterResistance = 1.0f / 6;
> const float VinConductance = 10;
> const float VinDivider = 11;
> const float V5vConductance = 10;
> const float V5vDivider = 2;
> const float VDDConductance = 3;
> const float VDDDivider = 2;
> const float VSaturationDivider = 3.12765f;
>
>
>
> const uint32_t maxSampleCount = 16000;
> const uint32_t maxMessageSize = (maxSampleCount + 4) * sizeof(float);
> const uint32_t maxMessageBlock = 2048;
> const uint16_t maxBlockSize = 2048;
>
> typedef unsigned char SPIchar;
> typedef std::basic_string<SPIchar> SPIstring;
> const double mechMinAltitude = -60;
> const double mechMaxAltitude = 40;
>
> const uint32_t SPIbusSpeed = 8000000;
>
>
>
>
>
> enum rgain
> {
> g1 = 0,
> g3,
> g5,
> g10,
> g30,
> g50,
> g100,
> g150,
> g500,
> g750
> };
>
> const int minGain = int(g1);
> const int maxGain = int(g750);
>
> enum rbw
> {
> bw200 = 0,
> bw2000
> };
>
>
>
> typedef uint32_t caps[6];
>
>
>
> struct allCapabilitiesStruct
> {
> uint32_t version;
> caps horiz;
> caps vert;
> caps sensor;
> caps self;
> };
>
>
>
>
> typedef uint16_t tpower;
>
> class wildfireStatus;
> void setGPIO(const uint8_t gpio, const bool val);
>
>
>
>
> class iWCCclass
> {
> private:
> tpower transmitterPower;
> rgain receiverGain;
> bool feedbackLow;
> bool autogain;
> uint32_t sampleRate;
> uint32_t repeats;
> uint32_t messageSize;
> int fd;
> SPIchar *message;
>
> void sendToiWCC(const SPIstring &m);
> void sendMessage(uint32_t messageSize);
> void readFromiWCC(void);
> void SPIputGetChar(const SPIchar *p,SPIchar *g);
> void SPIputGetNChars(const uint32_t n, const SPIchar *p,SPIchar *g);
>
> public:
>
> double horizSensorPosition;
> double vertSensorPosition;
>
> iWCCclass(const wildfireStatus &stats);
>
> void setReceiverFeedback(const bool f);
> void setReceiverGain(const rgain g);
> void setReceiverAutogain(const bool a);
> void setRepeats(const unsigned short r);
> void setRate(const unsigned long r);
> void setChannel(const channels c);
> void setTransmitterPower(const tpower p);
> void setMoveCurrent(const double i);
> void setStopCurrent(const double i);
> void setPosition(const double h, const double v);
> void setSensorPositions(const double h, const double v);
> uint8_t setCode(const uint16_t codeLength, const uint16_t oversampling, const uint32_t frequency, const double *code);
> void doCapture(void);
> void moveTo(const double h, const double v);
> void reset(const wildfireStatus &stats, bool setSensorPos = true);
> void validateAxf(const std::string * filename);
> bool writeFirmware(const boardType board, const std::string * filename);
> bool readFirmware(const boardType board, const std::string * filename);
> bool doCalibrate(const boardType board, const uint8_t boardNumber, float *hInit, float *hNew);
> float *getSamples(uint32_t &sampleCount);
> void getSaturationLevel(void);
> void getCapabilities(allCapabilitiesStruct *data);
> double getSingleValue(const channels c, const uint32_t r = 1);
> bool getReceiverFeedback(void);
> void getPosition(double *h, double *v);
> void getLocalTemp(double *t);
> uint8_t *getID(void);
> uint32_t *getStatus(void);
> void setRelay1state(const bool state) { setGPIO(143, state);};
> void setRelay2state(const bool state) { setGPIO(145, state);};
> void setDummyLoad(const bool state);
> };
>
>
>
>}
># 25 "../src/wildfire.h" 2
># 1 "../src/except.h" 1
># 17 "../src/except.h"
># 1 "/usr/include/c++/4.8.2/fstream" 1 3
># 36 "/usr/include/c++/4.8.2/fstream" 3
> 
># 37 "/usr/include/c++/4.8.2/fstream" 3
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/codecvt.h" 1 3
># 39 "/usr/include/c++/4.8.2/bits/codecvt.h" 3
> 
># 40 "/usr/include/c++/4.8.2/bits/codecvt.h" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> class codecvt_base
> {
> public:
> enum result
> {
> ok,
> partial,
> error,
> noconv
> };
> };
># 67 "/usr/include/c++/4.8.2/bits/codecvt.h" 3
> template<typename _InternT, typename _ExternT, typename _StateT>
> class __codecvt_abstract_base
> : public locale::facet, public codecvt_base
> {
> public:
>
> typedef codecvt_base::result result;
> typedef _InternT intern_type;
> typedef _ExternT extern_type;
> typedef _StateT state_type;
># 115 "/usr/include/c++/4.8.2/bits/codecvt.h" 3
> result
> out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const
> {
> return this->do_out(__state, __from, __from_end, __from_next,
> __to, __to_end, __to_next);
> }
># 154 "/usr/include/c++/4.8.2/bits/codecvt.h" 3
> result
> unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const
> { return this->do_unshift(__state, __to,__to_end,__to_next); }
># 195 "/usr/include/c++/4.8.2/bits/codecvt.h" 3
> result
> in(state_type& __state, const extern_type* __from,
> const extern_type* __from_end, const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const
> {
> return this->do_in(__state, __from, __from_end, __from_next,
> __to, __to_end, __to_next);
> }
>
> int
> encoding() const throw()
> { return this->do_encoding(); }
>
> bool
> always_noconv() const throw()
> { return this->do_always_noconv(); }
>
> int
> length(state_type& __state, const extern_type* __from,
> const extern_type* __end, size_t __max) const
> { return this->do_length(__state, __from, __end, __max); }
>
> int
> max_length() const throw()
> { return this->do_max_length(); }
>
> protected:
> explicit
> __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }
>
> virtual
> ~__codecvt_abstract_base() { }
># 236 "/usr/include/c++/4.8.2/bits/codecvt.h" 3
> virtual result
> do_out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const = 0;
>
> virtual result
> do_unshift(state_type& __state, extern_type* __to,
> extern_type* __to_end, extern_type*& __to_next) const = 0;
>
> virtual result
> do_in(state_type& __state, const extern_type* __from,
> const extern_type* __from_end, const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const = 0;
>
> virtual int
> do_encoding() const throw() = 0;
>
> virtual bool
> do_always_noconv() const throw() = 0;
>
> virtual int
> do_length(state_type&, const extern_type* __from,
> const extern_type* __end, size_t __max) const = 0;
>
> virtual int
> do_max_length() const throw() = 0;
> };
># 275 "/usr/include/c++/4.8.2/bits/codecvt.h" 3
> template<typename _InternT, typename _ExternT, typename _StateT>
> class codecvt
> : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
> {
> public:
>
> typedef codecvt_base::result result;
> typedef _InternT intern_type;
> typedef _ExternT extern_type;
> typedef _StateT state_type;
>
> protected:
> __c_locale _M_c_locale_codecvt;
>
> public:
> static locale::id id;
>
> explicit
> codecvt(size_t __refs = 0)
> : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs),
> _M_c_locale_codecvt(0)
> { }
>
> explicit
> codecvt(__c_locale __cloc, size_t __refs = 0);
>
> protected:
> virtual
> ~codecvt() { }
>
> virtual result
> do_out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const;
>
> virtual result
> do_unshift(state_type& __state, extern_type* __to,
> extern_type* __to_end, extern_type*& __to_next) const;
>
> virtual result
> do_in(state_type& __state, const extern_type* __from,
> const extern_type* __from_end, const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const;
>
> virtual int
> do_encoding() const throw();
>
> virtual bool
> do_always_noconv() const throw();
>
> virtual int
> do_length(state_type&, const extern_type* __from,
> const extern_type* __end, size_t __max) const;
>
> virtual int
> do_max_length() const throw();
> };
>
> template<typename _InternT, typename _ExternT, typename _StateT>
> locale::id codecvt<_InternT, _ExternT, _StateT>::id;
>
>
> template<>
> class codecvt<char, char, mbstate_t>
> : public __codecvt_abstract_base<char, char, mbstate_t>
> {
> public:
>
> typedef char intern_type;
> typedef char extern_type;
> typedef mbstate_t state_type;
>
> protected:
> __c_locale _M_c_locale_codecvt;
>
> public:
> static locale::id id;
>
> explicit
> codecvt(size_t __refs = 0);
>
> explicit
> codecvt(__c_locale __cloc, size_t __refs = 0);
>
> protected:
> virtual
> ~codecvt();
>
> virtual result
> do_out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const;
>
> virtual result
> do_unshift(state_type& __state, extern_type* __to,
> extern_type* __to_end, extern_type*& __to_next) const;
>
> virtual result
> do_in(state_type& __state, const extern_type* __from,
> const extern_type* __from_end, const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const;
>
> virtual int
> do_encoding() const throw();
>
> virtual bool
> do_always_noconv() const throw();
>
> virtual int
> do_length(state_type&, const extern_type* __from,
> const extern_type* __end, size_t __max) const;
>
> virtual int
> do_max_length() const throw();
> };
>
>
>
> template<>
> class codecvt<wchar_t, char, mbstate_t>
> : public __codecvt_abstract_base<wchar_t, char, mbstate_t>
> {
> public:
>
> typedef wchar_t intern_type;
> typedef char extern_type;
> typedef mbstate_t state_type;
>
> protected:
> __c_locale _M_c_locale_codecvt;
>
> public:
> static locale::id id;
>
> explicit
> codecvt(size_t __refs = 0);
>
> explicit
> codecvt(__c_locale __cloc, size_t __refs = 0);
>
> protected:
> virtual
> ~codecvt();
>
> virtual result
> do_out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const;
>
> virtual result
> do_unshift(state_type& __state,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const;
>
> virtual result
> do_in(state_type& __state,
> const extern_type* __from, const extern_type* __from_end,
> const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const;
>
> virtual
> int do_encoding() const throw();
>
> virtual
> bool do_always_noconv() const throw();
>
> virtual
> int do_length(state_type&, const extern_type* __from,
> const extern_type* __end, size_t __max) const;
>
> virtual int
> do_max_length() const throw();
> };
>
>
>
> template<typename _InternT, typename _ExternT, typename _StateT>
> class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
> {
> public:
> explicit
> codecvt_byname(const char* __s, size_t __refs = 0)
> : codecvt<_InternT, _ExternT, _StateT>(__refs)
> {
> if (__builtin_strcmp(__s, "C") != 0
> && __builtin_strcmp(__s, "POSIX") != 0)
> {
> this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
> this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
> }
> }
>
> protected:
> virtual
> ~codecvt_byname() { }
> };
>
>
>
>
> extern template class codecvt_byname<char, char, mbstate_t>;
>
> extern template
> const codecvt<char, char, mbstate_t>&
> use_facet<codecvt<char, char, mbstate_t> >(const locale&);
>
> extern template
> bool
> has_facet<codecvt<char, char, mbstate_t> >(const locale&);
>
>
> extern template class codecvt_byname<wchar_t, char, mbstate_t>;
>
> extern template
> const codecvt<wchar_t, char, mbstate_t>&
> use_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
>
> extern template
> bool
> has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
>
>
>
>
>}
># 41 "/usr/include/c++/4.8.2/fstream" 2 3
># 1 "/usr/include/c++/4.8.2/cstdio" 1 3
># 39 "/usr/include/c++/4.8.2/cstdio" 3
> 
># 40 "/usr/include/c++/4.8.2/cstdio" 3
># 42 "/usr/include/c++/4.8.2/fstream" 2 3
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/basic_file.h" 1 3
># 37 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/basic_file.h" 3
> 
># 38 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/basic_file.h" 3
>
>
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++io.h" 1 3
># 35 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++io.h" 3
># 1 "/usr/include/c++/4.8.2/cstdio" 1 3
># 39 "/usr/include/c++/4.8.2/cstdio" 3
> 
># 40 "/usr/include/c++/4.8.2/cstdio" 3
># 36 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++io.h" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> typedef __gthread_mutex_t __c_lock;
>
>
> typedef FILE __c_file;
>
>
>}
># 41 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/basic_file.h" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _CharT>
> class __basic_file;
>
>
> template<>
> class __basic_file<char>
> {
>
> __c_file* _M_cfile;
>
>
> bool _M_cfile_created;
>
> public:
> __basic_file(__c_lock* __lock = 0) throw ();
>
> __basic_file*
> open(const char* __name, ios_base::openmode __mode, int __prot = 0664);
>
> __basic_file*
> sys_open(__c_file* __file, ios_base::openmode);
>
> __basic_file*
> sys_open(int __fd, ios_base::openmode __mode) throw ();
>
> __basic_file*
> close();
>
> __attribute__ ((__pure__)) bool
> is_open() const throw ();
>
> __attribute__ ((__pure__)) int
> fd() throw ();
>
> __attribute__ ((__pure__)) __c_file*
> file() throw ();
>
> ~__basic_file();
>
> streamsize
> xsputn(const char* __s, streamsize __n);
>
> streamsize
> xsputn_2(const char* __s1, streamsize __n1,
> const char* __s2, streamsize __n2);
>
> streamsize
> xsgetn(char* __s, streamsize __n);
>
> streamoff
> seekoff(streamoff __off, ios_base::seekdir __way) throw ();
>
> int
> sync();
>
> streamsize
> showmanyc();
> };
>
>
>}
># 43 "/usr/include/c++/4.8.2/fstream" 2 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 71 "/usr/include/c++/4.8.2/fstream" 3
> template<typename _CharT, typename _Traits>
> class basic_filebuf : public basic_streambuf<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
> typedef basic_streambuf<char_type, traits_type> __streambuf_type;
> typedef basic_filebuf<char_type, traits_type> __filebuf_type;
> typedef __basic_file<char> __file_type;
> typedef typename traits_type::state_type __state_type;
> typedef codecvt<char_type, char, __state_type> __codecvt_type;
>
> friend class ios_base;
>
> protected:
>
>
> __c_lock _M_lock;
>
>
> __file_type _M_file;
>
>
> ios_base::openmode _M_mode;
>
>
> __state_type _M_state_beg;
>
>
>
>
> __state_type _M_state_cur;
>
>
>
> __state_type _M_state_last;
>
>
> char_type* _M_buf;
>
>
>
>
>
>
> size_t _M_buf_size;
>
>
> bool _M_buf_allocated;
># 133 "/usr/include/c++/4.8.2/fstream" 3
> bool _M_reading;
> bool _M_writing;
>
>
>
>
>
>
>
> char_type _M_pback;
> char_type* _M_pback_cur_save;
> char_type* _M_pback_end_save;
> bool _M_pback_init;
>
>
>
> const __codecvt_type* _M_codecvt;
>
>
>
>
>
>
> char* _M_ext_buf;
>
>
>
>
> streamsize _M_ext_buf_size;
>
>
>
>
>
>
> const char* _M_ext_next;
> char* _M_ext_end;
>
>
>
>
>
>
> void
> _M_create_pback()
> {
> if (!_M_pback_init)
> {
> _M_pback_cur_save = this->gptr();
> _M_pback_end_save = this->egptr();
> this->setg(&_M_pback, &_M_pback, &_M_pback + 1);
> _M_pback_init = true;
> }
> }
>
>
>
>
>
>
> void
> _M_destroy_pback() throw()
> {
> if (_M_pback_init)
> {
>
> _M_pback_cur_save += this->gptr() != this->eback();
> this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save);
> _M_pback_init = false;
> }
> }
>
> public:
>
>
>
>
>
>
>
> basic_filebuf();
>
>
>
>
> virtual
> ~basic_filebuf()
> { this->close(); }
>
>
>
>
>
> bool
> is_open() const throw()
> { return _M_file.is_open(); }
># 269 "/usr/include/c++/4.8.2/fstream" 3
> __filebuf_type*
> open(const char* __s, ios_base::openmode __mode);
># 279 "/usr/include/c++/4.8.2/fstream" 3
> __filebuf_type*
> open(const std::string& __s, ios_base::openmode __mode)
> { return open(__s.c_str(), __mode); }
># 296 "/usr/include/c++/4.8.2/fstream" 3
> __filebuf_type*
> close();
>
> protected:
> void
> _M_allocate_internal_buffer();
>
> void
> _M_destroy_internal_buffer() throw();
>
>
> virtual streamsize
> showmanyc();
>
>
>
>
>
>
> virtual int_type
> underflow();
>
> virtual int_type
> pbackfail(int_type __c = _Traits::eof());
># 328 "/usr/include/c++/4.8.2/fstream" 3
> virtual int_type
> overflow(int_type __c = _Traits::eof());
>
>
>
> bool
> _M_convert_to_external(char_type*, streamsize);
># 348 "/usr/include/c++/4.8.2/fstream" 3
> virtual __streambuf_type*
> setbuf(char_type* __s, streamsize __n);
>
> virtual pos_type
> seekoff(off_type __off, ios_base::seekdir __way,
> ios_base::openmode __mode = ios_base::in | ios_base::out);
>
> virtual pos_type
> seekpos(pos_type __pos,
> ios_base::openmode __mode = ios_base::in | ios_base::out);
>
>
> pos_type
> _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state);
>
> int
> _M_get_ext_pos(__state_type &__state);
>
> virtual int
> sync();
>
> virtual void
> imbue(const locale& __loc);
>
> virtual streamsize
> xsgetn(char_type* __s, streamsize __n);
>
> virtual streamsize
> xsputn(const char_type* __s, streamsize __n);
>
>
> bool
> _M_terminate_output();
># 394 "/usr/include/c++/4.8.2/fstream" 3
> void
> _M_set_buffer(streamsize __off)
> {
> const bool __testin = _M_mode & ios_base::in;
> const bool __testout = _M_mode & ios_base::out;
>
> if (__testin && __off > 0)
> this->setg(_M_buf, _M_buf, _M_buf + __off);
> else
> this->setg(_M_buf, _M_buf, _M_buf);
>
> if (__testout && __off == 0 && _M_buf_size > 1 )
> this->setp(_M_buf, _M_buf + _M_buf_size - 1);
> else
> this->setp(0, 0);
> }
> };
># 426 "/usr/include/c++/4.8.2/fstream" 3
> template<typename _CharT, typename _Traits>
> class basic_ifstream : public basic_istream<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
> typedef basic_filebuf<char_type, traits_type> __filebuf_type;
> typedef basic_istream<char_type, traits_type> __istream_type;
>
> private:
> __filebuf_type _M_filebuf;
>
> public:
># 453 "/usr/include/c++/4.8.2/fstream" 3
> basic_ifstream() : __istream_type(), _M_filebuf()
> { this->init(&_M_filebuf); }
># 466 "/usr/include/c++/4.8.2/fstream" 3
> explicit
> basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in)
> : __istream_type(), _M_filebuf()
> {
> this->init(&_M_filebuf);
> this->open(__s, __mode);
> }
># 482 "/usr/include/c++/4.8.2/fstream" 3
> explicit
> basic_ifstream(const std::string& __s,
> ios_base::openmode __mode = ios_base::in)
> : __istream_type(), _M_filebuf()
> {
> this->init(&_M_filebuf);
> this->open(__s, __mode);
> }
># 498 "/usr/include/c++/4.8.2/fstream" 3
> ~basic_ifstream()
> { }
># 508 "/usr/include/c++/4.8.2/fstream" 3
> __filebuf_type*
> rdbuf() const
> { return const_cast<__filebuf_type*>(&_M_filebuf); }
>
>
>
>
>
> bool
> is_open()
> { return _M_filebuf.is_open(); }
>
>
>
> bool
> is_open() const
> { return _M_filebuf.is_open(); }
># 537 "/usr/include/c++/4.8.2/fstream" 3
> void
> open(const char* __s, ios_base::openmode __mode = ios_base::in)
> {
> if (!_M_filebuf.open(__s, __mode | ios_base::in))
> this->setstate(ios_base::failbit);
> else
>
>
> this->clear();
> }
># 557 "/usr/include/c++/4.8.2/fstream" 3
> void
> open(const std::string& __s, ios_base::openmode __mode = ios_base::in)
> {
> if (!_M_filebuf.open(__s, __mode | ios_base::in))
> this->setstate(ios_base::failbit);
> else
>
>
> this->clear();
> }
># 575 "/usr/include/c++/4.8.2/fstream" 3
> void
> close()
> {
> if (!_M_filebuf.close())
> this->setstate(ios_base::failbit);
> }
> };
># 598 "/usr/include/c++/4.8.2/fstream" 3
> template<typename _CharT, typename _Traits>
> class basic_ofstream : public basic_ostream<_CharT,_Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
> typedef basic_filebuf<char_type, traits_type> __filebuf_type;
> typedef basic_ostream<char_type, traits_type> __ostream_type;
>
> private:
> __filebuf_type _M_filebuf;
>
> public:
># 625 "/usr/include/c++/4.8.2/fstream" 3
> basic_ofstream(): __ostream_type(), _M_filebuf()
> { this->init(&_M_filebuf); }
># 639 "/usr/include/c++/4.8.2/fstream" 3
> explicit
> basic_ofstream(const char* __s,
> ios_base::openmode __mode = ios_base::out|ios_base::trunc)
> : __ostream_type(), _M_filebuf()
> {
> this->init(&_M_filebuf);
> this->open(__s, __mode);
> }
># 657 "/usr/include/c++/4.8.2/fstream" 3
> explicit
> basic_ofstream(const std::string& __s,
> ios_base::openmode __mode = ios_base::out|ios_base::trunc)
> : __ostream_type(), _M_filebuf()
> {
> this->init(&_M_filebuf);
> this->open(__s, __mode);
> }
># 673 "/usr/include/c++/4.8.2/fstream" 3
> ~basic_ofstream()
> { }
># 683 "/usr/include/c++/4.8.2/fstream" 3
> __filebuf_type*
> rdbuf() const
> { return const_cast<__filebuf_type*>(&_M_filebuf); }
>
>
>
>
>
> bool
> is_open()
> { return _M_filebuf.is_open(); }
>
>
>
> bool
> is_open() const
> { return _M_filebuf.is_open(); }
># 712 "/usr/include/c++/4.8.2/fstream" 3
> void
> open(const char* __s,
> ios_base::openmode __mode = ios_base::out | ios_base::trunc)
> {
> if (!_M_filebuf.open(__s, __mode | ios_base::out))
> this->setstate(ios_base::failbit);
> else
>
>
> this->clear();
> }
># 733 "/usr/include/c++/4.8.2/fstream" 3
> void
> open(const std::string& __s,
> ios_base::openmode __mode = ios_base::out | ios_base::trunc)
> {
> if (!_M_filebuf.open(__s, __mode | ios_base::out))
> this->setstate(ios_base::failbit);
> else
>
>
> this->clear();
> }
># 752 "/usr/include/c++/4.8.2/fstream" 3
> void
> close()
> {
> if (!_M_filebuf.close())
> this->setstate(ios_base::failbit);
> }
> };
># 775 "/usr/include/c++/4.8.2/fstream" 3
> template<typename _CharT, typename _Traits>
> class basic_fstream : public basic_iostream<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
> typedef basic_filebuf<char_type, traits_type> __filebuf_type;
> typedef basic_ios<char_type, traits_type> __ios_type;
> typedef basic_iostream<char_type, traits_type> __iostream_type;
>
> private:
> __filebuf_type _M_filebuf;
>
> public:
># 803 "/usr/include/c++/4.8.2/fstream" 3
> basic_fstream()
> : __iostream_type(), _M_filebuf()
> { this->init(&_M_filebuf); }
># 815 "/usr/include/c++/4.8.2/fstream" 3
> explicit
> basic_fstream(const char* __s,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> : __iostream_type(0), _M_filebuf()
> {
> this->init(&_M_filebuf);
> this->open(__s, __mode);
> }
>
>
>
>
>
>
>
> explicit
> basic_fstream(const std::string& __s,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> : __iostream_type(0), _M_filebuf()
> {
> this->init(&_M_filebuf);
> this->open(__s, __mode);
> }
># 846 "/usr/include/c++/4.8.2/fstream" 3
> ~basic_fstream()
> { }
># 856 "/usr/include/c++/4.8.2/fstream" 3
> __filebuf_type*
> rdbuf() const
> { return const_cast<__filebuf_type*>(&_M_filebuf); }
>
>
>
>
>
> bool
> is_open()
> { return _M_filebuf.is_open(); }
>
>
>
> bool
> is_open() const
> { return _M_filebuf.is_open(); }
># 885 "/usr/include/c++/4.8.2/fstream" 3
> void
> open(const char* __s,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> {
> if (!_M_filebuf.open(__s, __mode))
> this->setstate(ios_base::failbit);
> else
>
>
> this->clear();
> }
># 906 "/usr/include/c++/4.8.2/fstream" 3
> void
> open(const std::string& __s,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> {
> if (!_M_filebuf.open(__s, __mode))
> this->setstate(ios_base::failbit);
> else
>
>
> this->clear();
> }
># 925 "/usr/include/c++/4.8.2/fstream" 3
> void
> close()
> {
> if (!_M_filebuf.close())
> this->setstate(ios_base::failbit);
> }
> };
>
>
>}
>
># 1 "/usr/include/c++/4.8.2/bits/fstream.tcc" 1 3
># 37 "/usr/include/c++/4.8.2/bits/fstream.tcc" 3
> 
># 38 "/usr/include/c++/4.8.2/bits/fstream.tcc" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> void
> basic_filebuf<_CharT, _Traits>::
> _M_allocate_internal_buffer()
> {
>
>
> if (!_M_buf_allocated && !_M_buf)
> {
> _M_buf = new char_type[_M_buf_size];
> _M_buf_allocated = true;
> }
> }
>
> template<typename _CharT, typename _Traits>
> void
> basic_filebuf<_CharT, _Traits>::
> _M_destroy_internal_buffer() throw()
> {
> if (_M_buf_allocated)
> {
> delete [] _M_buf;
> _M_buf = 0;
> _M_buf_allocated = false;
> }
> delete [] _M_ext_buf;
> _M_ext_buf = 0;
> _M_ext_buf_size = 0;
> _M_ext_next = 0;
> _M_ext_end = 0;
> }
>
> template<typename _CharT, typename _Traits>
> basic_filebuf<_CharT, _Traits>::
> basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock),
> _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(),
> _M_state_last(), _M_buf(0), _M_buf_size(8192),
> _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(),
> _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false),
> _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0),
> _M_ext_end(0)
> {
> if (has_facet<__codecvt_type>(this->_M_buf_locale))
> _M_codecvt = &use_facet<__codecvt_type>(this->_M_buf_locale);
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
> basic_filebuf<_CharT, _Traits>::
> open(const char* __s, ios_base::openmode __mode)
> {
> __filebuf_type *__ret = 0;
> if (!this->is_open())
> {
> _M_file.open(__s, __mode);
> if (this->is_open())
> {
> _M_allocate_internal_buffer();
> _M_mode = __mode;
>
>
> _M_reading = false;
> _M_writing = false;
> _M_set_buffer(-1);
>
>
> _M_state_last = _M_state_cur = _M_state_beg;
>
>
> if ((__mode & ios_base::ate)
> && this->seekoff(0, ios_base::end, __mode)
> == pos_type(off_type(-1)))
> this->close();
> else
> __ret = this;
> }
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
> basic_filebuf<_CharT, _Traits>::
> close()
> {
> if (!this->is_open())
> return 0;
>
> bool __testfail = false;
> {
>
> struct __close_sentry
> {
> basic_filebuf *__fb;
> __close_sentry (basic_filebuf *__fbi): __fb(__fbi) { }
> ~__close_sentry ()
> {
> __fb->_M_mode = ios_base::openmode(0);
> __fb->_M_pback_init = false;
> __fb->_M_destroy_internal_buffer();
> __fb->_M_reading = false;
> __fb->_M_writing = false;
> __fb->_M_set_buffer(-1);
> __fb->_M_state_last = __fb->_M_state_cur = __fb->_M_state_beg;
> }
> } __cs (this);
>
> try
> {
> if (!_M_terminate_output())
> __testfail = true;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> _M_file.close();
> throw;
> }
> catch(...)
> { __testfail = true; }
> }
>
> if (!_M_file.close())
> __testfail = true;
>
> if (__testfail)
> return 0;
> else
> return this;
> }
>
> template<typename _CharT, typename _Traits>
> streamsize
> basic_filebuf<_CharT, _Traits>::
> showmanyc()
> {
> streamsize __ret = -1;
> const bool __testin = _M_mode & ios_base::in;
> if (__testin && this->is_open())
> {
>
>
> __ret = this->egptr() - this->gptr();
>
>
>
>
>
>
>
> if (__check_facet(_M_codecvt).encoding() >= 0)
>
> __ret += _M_file.showmanyc() / _M_codecvt->max_length();
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_filebuf<_CharT, _Traits>::int_type
> basic_filebuf<_CharT, _Traits>::
> underflow()
> {
> int_type __ret = traits_type::eof();
> const bool __testin = _M_mode & ios_base::in;
> if (__testin)
> {
> if (_M_writing)
> {
> if (overflow() == traits_type::eof())
> return __ret;
> _M_set_buffer(-1);
> _M_writing = false;
> }
>
>
>
> _M_destroy_pback();
>
> if (this->gptr() < this->egptr())
> return traits_type::to_int_type(*this->gptr());
>
>
> const size_t __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;
>
>
> bool __got_eof = false;
>
> streamsize __ilen = 0;
> codecvt_base::result __r = codecvt_base::ok;
> if (__check_facet(_M_codecvt).always_noconv())
> {
> __ilen = _M_file.xsgetn(reinterpret_cast<char*>(this->eback()),
> __buflen);
> if (__ilen == 0)
> __got_eof = true;
> }
> else
> {
>
>
> const int __enc = _M_codecvt->encoding();
> streamsize __blen;
> streamsize __rlen;
> if (__enc > 0)
> __blen = __rlen = __buflen * __enc;
> else
> {
> __blen = __buflen + _M_codecvt->max_length() - 1;
> __rlen = __buflen;
> }
> const streamsize __remainder = _M_ext_end - _M_ext_next;
> __rlen = __rlen > __remainder ? __rlen - __remainder : 0;
>
>
>
> if (_M_reading && this->egptr() == this->eback() && __remainder)
> __rlen = 0;
>
>
>
> if (_M_ext_buf_size < __blen)
> {
> char* __buf = new char[__blen];
> if (__remainder)
> __builtin_memcpy(__buf, _M_ext_next, __remainder);
>
> delete [] _M_ext_buf;
> _M_ext_buf = __buf;
> _M_ext_buf_size = __blen;
> }
> else if (__remainder)
> __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);
>
> _M_ext_next = _M_ext_buf;
> _M_ext_end = _M_ext_buf + __remainder;
> _M_state_last = _M_state_cur;
>
> do
> {
> if (__rlen > 0)
> {
>
>
>
> if (_M_ext_end - _M_ext_buf + __rlen > _M_ext_buf_size)
> {
> __throw_ios_failure(("basic_filebuf::underflow " "codecvt::max_length() " "is not valid")
>
> );
> }
> streamsize __elen = _M_file.xsgetn(_M_ext_end, __rlen);
> if (__elen == 0)
> __got_eof = true;
> else if (__elen == -1)
> break;
> _M_ext_end += __elen;
> }
>
> char_type* __iend = this->eback();
> if (_M_ext_next < _M_ext_end)
> __r = _M_codecvt->in(_M_state_cur, _M_ext_next,
> _M_ext_end, _M_ext_next,
> this->eback(),
> this->eback() + __buflen, __iend);
> if (__r == codecvt_base::noconv)
> {
> size_t __avail = _M_ext_end - _M_ext_buf;
> __ilen = std::min(__avail, __buflen);
> traits_type::copy(this->eback(),
> reinterpret_cast<char_type*>
> (_M_ext_buf), __ilen);
> _M_ext_next = _M_ext_buf + __ilen;
> }
> else
> __ilen = __iend - this->eback();
>
>
>
>
> if (__r == codecvt_base::error)
> break;
>
> __rlen = 1;
> }
> while (__ilen == 0 && !__got_eof);
> }
>
> if (__ilen > 0)
> {
> _M_set_buffer(__ilen);
> _M_reading = true;
> __ret = traits_type::to_int_type(*this->gptr());
> }
> else if (__got_eof)
> {
>
>
>
> _M_set_buffer(-1);
> _M_reading = false;
>
>
> if (__r == codecvt_base::partial)
> __throw_ios_failure(("basic_filebuf::underflow " "incomplete character in file")
> );
> }
> else if (__r == codecvt_base::error)
> __throw_ios_failure(("basic_filebuf::underflow " "invalid byte sequence in file")
> );
> else
> __throw_ios_failure(("basic_filebuf::underflow " "error reading the file")
> );
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_filebuf<_CharT, _Traits>::int_type
> basic_filebuf<_CharT, _Traits>::
> pbackfail(int_type __i)
> {
> int_type __ret = traits_type::eof();
> const bool __testin = _M_mode & ios_base::in;
> if (__testin)
> {
> if (_M_writing)
> {
> if (overflow() == traits_type::eof())
> return __ret;
> _M_set_buffer(-1);
> _M_writing = false;
> }
>
>
> const bool __testpb = _M_pback_init;
> const bool __testeof = traits_type::eq_int_type(__i, __ret);
> int_type __tmp;
> if (this->eback() < this->gptr())
> {
> this->gbump(-1);
> __tmp = traits_type::to_int_type(*this->gptr());
> }
> else if (this->seekoff(-1, ios_base::cur) != pos_type(off_type(-1)))
> {
> __tmp = this->underflow();
> if (traits_type::eq_int_type(__tmp, __ret))
> return __ret;
> }
> else
> {
>
>
>
>
>
> return __ret;
> }
>
>
>
> if (!__testeof && traits_type::eq_int_type(__i, __tmp))
> __ret = __i;
> else if (__testeof)
> __ret = traits_type::not_eof(__i);
> else if (!__testpb)
> {
> _M_create_pback();
> _M_reading = true;
> *this->gptr() = traits_type::to_char_type(__i);
> __ret = __i;
> }
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_filebuf<_CharT, _Traits>::int_type
> basic_filebuf<_CharT, _Traits>::
> overflow(int_type __c)
> {
> int_type __ret = traits_type::eof();
> const bool __testeof = traits_type::eq_int_type(__c, __ret);
> const bool __testout = _M_mode & ios_base::out;
> if (__testout)
> {
> if (_M_reading)
> {
> _M_destroy_pback();
> const int __gptr_off = _M_get_ext_pos(_M_state_last);
> if (_M_seek(__gptr_off, ios_base::cur, _M_state_last)
> == pos_type(off_type(-1)))
> return __ret;
> }
> if (this->pbase() < this->pptr())
> {
>
> if (!__testeof)
> {
> *this->pptr() = traits_type::to_char_type(__c);
> this->pbump(1);
> }
>
>
>
> if (_M_convert_to_external(this->pbase(),
> this->pptr() - this->pbase()))
> {
> _M_set_buffer(0);
> __ret = traits_type::not_eof(__c);
> }
> }
> else if (_M_buf_size > 1)
> {
>
>
>
> _M_set_buffer(0);
> _M_writing = true;
> if (!__testeof)
> {
> *this->pptr() = traits_type::to_char_type(__c);
> this->pbump(1);
> }
> __ret = traits_type::not_eof(__c);
> }
> else
> {
>
> char_type __conv = traits_type::to_char_type(__c);
> if (__testeof || _M_convert_to_external(&__conv, 1))
> {
> _M_writing = true;
> __ret = traits_type::not_eof(__c);
> }
> }
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> bool
> basic_filebuf<_CharT, _Traits>::
> _M_convert_to_external(_CharT* __ibuf, streamsize __ilen)
> {
>
> streamsize __elen;
> streamsize __plen;
> if (__check_facet(_M_codecvt).always_noconv())
> {
> __elen = _M_file.xsputn(reinterpret_cast<char*>(__ibuf), __ilen);
> __plen = __ilen;
> }
> else
> {
>
>
> streamsize __blen = __ilen * _M_codecvt->max_length();
> char* __buf = static_cast<char*>(__builtin_alloca(__blen));
>
> char* __bend;
> const char_type* __iend;
> codecvt_base::result __r;
> __r = _M_codecvt->out(_M_state_cur, __ibuf, __ibuf + __ilen,
> __iend, __buf, __buf + __blen, __bend);
>
> if (__r == codecvt_base::ok || __r == codecvt_base::partial)
> __blen = __bend - __buf;
> else if (__r == codecvt_base::noconv)
> {
>
> __buf = reinterpret_cast<char*>(__ibuf);
> __blen = __ilen;
> }
> else
> __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error")
> );
>
> __elen = _M_file.xsputn(__buf, __blen);
> __plen = __blen;
>
>
> if (__r == codecvt_base::partial && __elen == __plen)
> {
> const char_type* __iresume = __iend;
> streamsize __rlen = this->pptr() - __iend;
> __r = _M_codecvt->out(_M_state_cur, __iresume,
> __iresume + __rlen, __iend, __buf,
> __buf + __blen, __bend);
> if (__r != codecvt_base::error)
> {
> __rlen = __bend - __buf;
> __elen = _M_file.xsputn(__buf, __rlen);
> __plen = __rlen;
> }
> else
> __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error")
> );
> }
> }
> return __elen == __plen;
> }
>
> template<typename _CharT, typename _Traits>
> streamsize
> basic_filebuf<_CharT, _Traits>::
> xsgetn(_CharT* __s, streamsize __n)
> {
>
> streamsize __ret = 0;
> if (_M_pback_init)
> {
> if (__n > 0 && this->gptr() == this->eback())
> {
> *__s++ = *this->gptr();
> this->gbump(1);
> __ret = 1;
> --__n;
> }
> _M_destroy_pback();
> }
> else if (_M_writing)
> {
> if (overflow() == traits_type::eof())
> return __ret;
> _M_set_buffer(-1);
> _M_writing = false;
> }
>
>
>
>
> const bool __testin = _M_mode & ios_base::in;
> const streamsize __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;
>
> if (__n > __buflen && __check_facet(_M_codecvt).always_noconv()
> && __testin)
> {
>
> const streamsize __avail = this->egptr() - this->gptr();
> if (__avail != 0)
> {
> traits_type::copy(__s, this->gptr(), __avail);
> __s += __avail;
> this->setg(this->eback(), this->gptr() + __avail,
> this->egptr());
> __ret += __avail;
> __n -= __avail;
> }
>
>
>
> streamsize __len;
> for (;;)
> {
> __len = _M_file.xsgetn(reinterpret_cast<char*>(__s),
> __n);
> if (__len == -1)
> __throw_ios_failure(("basic_filebuf::xsgetn " "error reading the file")
> );
> if (__len == 0)
> break;
>
> __n -= __len;
> __ret += __len;
> if (__n == 0)
> break;
>
> __s += __len;
> }
>
> if (__n == 0)
> {
> _M_set_buffer(0);
> _M_reading = true;
> }
> else if (__len == 0)
> {
>
>
>
> _M_set_buffer(-1);
> _M_reading = false;
> }
> }
> else
> __ret += __streambuf_type::xsgetn(__s, __n);
>
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> streamsize
> basic_filebuf<_CharT, _Traits>::
> xsputn(const _CharT* __s, streamsize __n)
> {
> streamsize __ret = 0;
>
>
>
> const bool __testout = _M_mode & ios_base::out;
> if (__check_facet(_M_codecvt).always_noconv()
> && __testout && !_M_reading)
> {
>
> const streamsize __chunk = 1ul << 10;
> streamsize __bufavail = this->epptr() - this->pptr();
>
>
> if (!_M_writing && _M_buf_size > 1)
> __bufavail = _M_buf_size - 1;
>
> const streamsize __limit = std::min(__chunk, __bufavail);
> if (__n >= __limit)
> {
> const streamsize __buffill = this->pptr() - this->pbase();
> const char* __buf = reinterpret_cast<const char*>(this->pbase());
> __ret = _M_file.xsputn_2(__buf, __buffill,
> reinterpret_cast<const char*>(__s),
> __n);
> if (__ret == __buffill + __n)
> {
> _M_set_buffer(0);
> _M_writing = true;
> }
> if (__ret > __buffill)
> __ret -= __buffill;
> else
> __ret = 0;
> }
> else
> __ret = __streambuf_type::xsputn(__s, __n);
> }
> else
> __ret = __streambuf_type::xsputn(__s, __n);
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_filebuf<_CharT, _Traits>::__streambuf_type*
> basic_filebuf<_CharT, _Traits>::
> setbuf(char_type* __s, streamsize __n)
> {
> if (!this->is_open())
> {
> if (__s == 0 && __n == 0)
> _M_buf_size = 1;
> else if (__s && __n > 0)
> {
># 700 "/usr/include/c++/4.8.2/bits/fstream.tcc" 3
> _M_buf = __s;
> _M_buf_size = __n;
> }
> }
> return this;
> }
>
>
>
>
> template<typename _CharT, typename _Traits>
> typename basic_filebuf<_CharT, _Traits>::pos_type
> basic_filebuf<_CharT, _Traits>::
> seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode)
> {
> int __width = 0;
> if (_M_codecvt)
> __width = _M_codecvt->encoding();
> if (__width < 0)
> __width = 0;
>
> pos_type __ret = pos_type(off_type(-1));
> const bool __testfail = __off != 0 && __width <= 0;
> if (this->is_open() && !__testfail)
> {
>
>
>
>
> bool __no_movement = __way == ios_base::cur && __off == 0
> && (!_M_writing || _M_codecvt->always_noconv());
>
>
> if (!__no_movement)
> _M_destroy_pback();
>
>
>
>
>
>
> __state_type __state = _M_state_beg;
> off_type __computed_off = __off * __width;
> if (_M_reading && __way == ios_base::cur)
> {
> __state = _M_state_last;
> __computed_off += _M_get_ext_pos(__state);
> }
> if (!__no_movement)
> __ret = _M_seek(__computed_off, __way, __state);
> else
> {
> if (_M_writing)
> __computed_off = this->pptr() - this->pbase();
>
> off_type __file_off = _M_file.seekoff(0, ios_base::cur);
> if (__file_off != off_type(-1))
> {
> __ret = __file_off + __computed_off;
> __ret.state(__state);
> }
> }
> }
> return __ret;
> }
>
>
>
>
>
> template<typename _CharT, typename _Traits>
> typename basic_filebuf<_CharT, _Traits>::pos_type
> basic_filebuf<_CharT, _Traits>::
> seekpos(pos_type __pos, ios_base::openmode)
> {
> pos_type __ret = pos_type(off_type(-1));
> if (this->is_open())
> {
>
> _M_destroy_pback();
> __ret = _M_seek(off_type(__pos), ios_base::beg, __pos.state());
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_filebuf<_CharT, _Traits>::pos_type
> basic_filebuf<_CharT, _Traits>::
> _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state)
> {
> pos_type __ret = pos_type(off_type(-1));
> if (_M_terminate_output())
> {
> off_type __file_off = _M_file.seekoff(__off, __way);
> if (__file_off != off_type(-1))
> {
> _M_reading = false;
> _M_writing = false;
> _M_ext_next = _M_ext_end = _M_ext_buf;
> _M_set_buffer(-1);
> _M_state_cur = __state;
> __ret = __file_off;
> __ret.state(_M_state_cur);
> }
> }
> return __ret;
> }
>
>
>
>
> template<typename _CharT, typename _Traits>
> int basic_filebuf<_CharT, _Traits>::
> _M_get_ext_pos(__state_type& __state)
> {
> if (_M_codecvt->always_noconv())
> return this->gptr() - this->egptr();
> else
> {
>
>
>
> const int __gptr_off =
> _M_codecvt->length(__state, _M_ext_buf, _M_ext_next,
> this->gptr() - this->eback());
> return _M_ext_buf + __gptr_off - _M_ext_end;
> }
> }
>
> template<typename _CharT, typename _Traits>
> bool
> basic_filebuf<_CharT, _Traits>::
> _M_terminate_output()
> {
>
> bool __testvalid = true;
> if (this->pbase() < this->pptr())
> {
> const int_type __tmp = this->overflow();
> if (traits_type::eq_int_type(__tmp, traits_type::eof()))
> __testvalid = false;
> }
>
>
> if (_M_writing && !__check_facet(_M_codecvt).always_noconv()
> && __testvalid)
> {
>
>
>
> const size_t __blen = 128;
> char __buf[__blen];
> codecvt_base::result __r;
> streamsize __ilen = 0;
>
> do
> {
> char* __next;
> __r = _M_codecvt->unshift(_M_state_cur, __buf,
> __buf + __blen, __next);
> if (__r == codecvt_base::error)
> __testvalid = false;
> else if (__r == codecvt_base::ok ||
> __r == codecvt_base::partial)
> {
> __ilen = __next - __buf;
> if (__ilen > 0)
> {
> const streamsize __elen = _M_file.xsputn(__buf, __ilen);
> if (__elen != __ilen)
> __testvalid = false;
> }
> }
> }
> while (__r == codecvt_base::partial && __ilen > 0 && __testvalid);
>
> if (__testvalid)
> {
>
>
>
>
> const int_type __tmp = this->overflow();
> if (traits_type::eq_int_type(__tmp, traits_type::eof()))
> __testvalid = false;
> }
> }
> return __testvalid;
> }
>
> template<typename _CharT, typename _Traits>
> int
> basic_filebuf<_CharT, _Traits>::
> sync()
> {
>
>
> int __ret = 0;
> if (this->pbase() < this->pptr())
> {
> const int_type __tmp = this->overflow();
> if (traits_type::eq_int_type(__tmp, traits_type::eof()))
> __ret = -1;
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> void
> basic_filebuf<_CharT, _Traits>::
> imbue(const locale& __loc)
> {
> bool __testvalid = true;
>
> const __codecvt_type* _M_codecvt_tmp = 0;
> if (__builtin_expect(has_facet<__codecvt_type>(__loc), true))
> _M_codecvt_tmp = &use_facet<__codecvt_type>(__loc);
>
> if (this->is_open())
> {
>
> if ((_M_reading || _M_writing)
> && __check_facet(_M_codecvt).encoding() == -1)
> __testvalid = false;
> else
> {
> if (_M_reading)
> {
> if (__check_facet(_M_codecvt).always_noconv())
> {
> if (_M_codecvt_tmp
> && !__check_facet(_M_codecvt_tmp).always_noconv())
> __testvalid = this->seekoff(0, ios_base::cur, _M_mode)
> != pos_type(off_type(-1));
> }
> else
> {
>
> _M_ext_next = _M_ext_buf
> + _M_codecvt->length(_M_state_last, _M_ext_buf,
> _M_ext_next,
> this->gptr() - this->eback());
> const streamsize __remainder = _M_ext_end - _M_ext_next;
> if (__remainder)
> __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);
>
> _M_ext_next = _M_ext_buf;
> _M_ext_end = _M_ext_buf + __remainder;
> _M_set_buffer(-1);
> _M_state_last = _M_state_cur = _M_state_beg;
> }
> }
> else if (_M_writing && (__testvalid = _M_terminate_output()))
> _M_set_buffer(-1);
> }
> }
>
> if (__testvalid)
> _M_codecvt = _M_codecvt_tmp;
> else
> _M_codecvt = 0;
> }
>
>
>
>
> extern template class basic_filebuf<char>;
> extern template class basic_ifstream<char>;
> extern template class basic_ofstream<char>;
> extern template class basic_fstream<char>;
>
>
> extern template class basic_filebuf<wchar_t>;
> extern template class basic_ifstream<wchar_t>;
> extern template class basic_ofstream<wchar_t>;
> extern template class basic_fstream<wchar_t>;
>
>
>
>
>}
># 937 "/usr/include/c++/4.8.2/fstream" 2 3
># 18 "../src/except.h" 2
>
># 1 "/usr/include/c++/4.8.2/map" 1 3
># 58 "/usr/include/c++/4.8.2/map" 3
> 
># 59 "/usr/include/c++/4.8.2/map" 3
>
># 1 "/usr/include/c++/4.8.2/bits/stl_tree.h" 1 3
># 69 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 89 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
> enum _Rb_tree_color { _S_red = false, _S_black = true };
>
> struct _Rb_tree_node_base
> {
> typedef _Rb_tree_node_base* _Base_ptr;
> typedef const _Rb_tree_node_base* _Const_Base_ptr;
>
> _Rb_tree_color _M_color;
> _Base_ptr _M_parent;
> _Base_ptr _M_left;
> _Base_ptr _M_right;
>
> static _Base_ptr
> _S_minimum(_Base_ptr __x)
> {
> while (__x->_M_left != 0) __x = __x->_M_left;
> return __x;
> }
>
> static _Const_Base_ptr
> _S_minimum(_Const_Base_ptr __x)
> {
> while (__x->_M_left != 0) __x = __x->_M_left;
> return __x;
> }
>
> static _Base_ptr
> _S_maximum(_Base_ptr __x)
> {
> while (__x->_M_right != 0) __x = __x->_M_right;
> return __x;
> }
>
> static _Const_Base_ptr
> _S_maximum(_Const_Base_ptr __x)
> {
> while (__x->_M_right != 0) __x = __x->_M_right;
> return __x;
> }
> };
>
> template<typename _Val>
> struct _Rb_tree_node : public _Rb_tree_node_base
> {
> typedef _Rb_tree_node<_Val>* _Link_type;
> _Val _M_value_field;
>
>
> template<typename... _Args>
> _Rb_tree_node(_Args&&... __args)
> : _Rb_tree_node_base(),
> _M_value_field(std::forward<_Args>(__args)...) { }
>
> };
>
> __attribute__ ((__pure__)) _Rb_tree_node_base*
> _Rb_tree_increment(_Rb_tree_node_base* __x) throw ();
>
> __attribute__ ((__pure__)) const _Rb_tree_node_base*
> _Rb_tree_increment(const _Rb_tree_node_base* __x) throw ();
>
> __attribute__ ((__pure__)) _Rb_tree_node_base*
> _Rb_tree_decrement(_Rb_tree_node_base* __x) throw ();
>
> __attribute__ ((__pure__)) const _Rb_tree_node_base*
> _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw ();
>
> template<typename _Tp>
> struct _Rb_tree_iterator
> {
> typedef _Tp value_type;
> typedef _Tp& reference;
> typedef _Tp* pointer;
>
> typedef bidirectional_iterator_tag iterator_category;
> typedef ptrdiff_t difference_type;
>
> typedef _Rb_tree_iterator<_Tp> _Self;
> typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
> typedef _Rb_tree_node<_Tp>* _Link_type;
>
> _Rb_tree_iterator()
> : _M_node() { }
>
> explicit
> _Rb_tree_iterator(_Link_type __x)
> : _M_node(__x) { }
>
> reference
> operator*() const
> { return static_cast<_Link_type>(_M_node)->_M_value_field; }
>
> pointer
> operator->() const
> { return std::__addressof(static_cast<_Link_type>
> (_M_node)->_M_value_field); }
>
> _Self&
> operator++()
> {
> _M_node = _Rb_tree_increment(_M_node);
> return *this;
> }
>
> _Self
> operator++(int)
> {
> _Self __tmp = *this;
> _M_node = _Rb_tree_increment(_M_node);
> return __tmp;
> }
>
> _Self&
> operator--()
> {
> _M_node = _Rb_tree_decrement(_M_node);
> return *this;
> }
>
> _Self
> operator--(int)
> {
> _Self __tmp = *this;
> _M_node = _Rb_tree_decrement(_M_node);
> return __tmp;
> }
>
> bool
> operator==(const _Self& __x) const
> { return _M_node == __x._M_node; }
>
> bool
> operator!=(const _Self& __x) const
> { return _M_node != __x._M_node; }
>
> _Base_ptr _M_node;
> };
>
> template<typename _Tp>
> struct _Rb_tree_const_iterator
> {
> typedef _Tp value_type;
> typedef const _Tp& reference;
> typedef const _Tp* pointer;
>
> typedef _Rb_tree_iterator<_Tp> iterator;
>
> typedef bidirectional_iterator_tag iterator_category;
> typedef ptrdiff_t difference_type;
>
> typedef _Rb_tree_const_iterator<_Tp> _Self;
> typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
> typedef const _Rb_tree_node<_Tp>* _Link_type;
>
> _Rb_tree_const_iterator()
> : _M_node() { }
>
> explicit
> _Rb_tree_const_iterator(_Link_type __x)
> : _M_node(__x) { }
>
> _Rb_tree_const_iterator(const iterator& __it)
> : _M_node(__it._M_node) { }
>
> iterator
> _M_const_cast() const
> { return iterator(static_cast<typename iterator::_Link_type>
> (const_cast<typename iterator::_Base_ptr>(_M_node))); }
>
> reference
> operator*() const
> { return static_cast<_Link_type>(_M_node)->_M_value_field; }
>
> pointer
> operator->() const
> { return std::__addressof(static_cast<_Link_type>
> (_M_node)->_M_value_field); }
>
> _Self&
> operator++()
> {
> _M_node = _Rb_tree_increment(_M_node);
> return *this;
> }
>
> _Self
> operator++(int)
> {
> _Self __tmp = *this;
> _M_node = _Rb_tree_increment(_M_node);
> return __tmp;
> }
>
> _Self&
> operator--()
> {
> _M_node = _Rb_tree_decrement(_M_node);
> return *this;
> }
>
> _Self
> operator--(int)
> {
> _Self __tmp = *this;
> _M_node = _Rb_tree_decrement(_M_node);
> return __tmp;
> }
>
> bool
> operator==(const _Self& __x) const
> { return _M_node == __x._M_node; }
>
> bool
> operator!=(const _Self& __x) const
> { return _M_node != __x._M_node; }
>
> _Base_ptr _M_node;
> };
>
> template<typename _Val>
> inline bool
> operator==(const _Rb_tree_iterator<_Val>& __x,
> const _Rb_tree_const_iterator<_Val>& __y)
> { return __x._M_node == __y._M_node; }
>
> template<typename _Val>
> inline bool
> operator!=(const _Rb_tree_iterator<_Val>& __x,
> const _Rb_tree_const_iterator<_Val>& __y)
> { return __x._M_node != __y._M_node; }
>
> void
> _Rb_tree_insert_and_rebalance(const bool __insert_left,
> _Rb_tree_node_base* __x,
> _Rb_tree_node_base* __p,
> _Rb_tree_node_base& __header) throw ();
>
> _Rb_tree_node_base*
> _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
> _Rb_tree_node_base& __header) throw ();
>
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc = allocator<_Val> >
> class _Rb_tree
> {
> typedef typename _Alloc::template rebind<_Rb_tree_node<_Val> >::other
> _Node_allocator;
>
> protected:
> typedef _Rb_tree_node_base* _Base_ptr;
> typedef const _Rb_tree_node_base* _Const_Base_ptr;
>
> public:
> typedef _Key key_type;
> typedef _Val value_type;
> typedef value_type* pointer;
> typedef const value_type* const_pointer;
> typedef value_type& reference;
> typedef const value_type& const_reference;
> typedef _Rb_tree_node<_Val>* _Link_type;
> typedef const _Rb_tree_node<_Val>* _Const_Link_type;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Alloc allocator_type;
>
> _Node_allocator&
> _M_get_Node_allocator() noexcept
> { return *static_cast<_Node_allocator*>(&this->_M_impl); }
>
> const _Node_allocator&
> _M_get_Node_allocator() const noexcept
> { return *static_cast<const _Node_allocator*>(&this->_M_impl); }
>
> allocator_type
> get_allocator() const noexcept
> { return allocator_type(_M_get_Node_allocator()); }
>
> protected:
> _Link_type
> _M_get_node()
> { return _M_impl._Node_allocator::allocate(1); }
>
> void
> _M_put_node(_Link_type __p)
> { _M_impl._Node_allocator::deallocate(__p, 1); }
># 399 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
> template<typename... _Args>
> _Link_type
> _M_create_node(_Args&&... __args)
> {
> _Link_type __tmp = _M_get_node();
> try
> {
> allocator_traits<_Node_allocator>::
> construct(_M_get_Node_allocator(), __tmp,
> std::forward<_Args>(__args)...);
> }
> catch(...)
> {
> _M_put_node(__tmp);
> throw;
> }
> return __tmp;
> }
>
> void
> _M_destroy_node(_Link_type __p)
> {
> _M_get_Node_allocator().destroy(__p);
> _M_put_node(__p);
> }
>
>
> _Link_type
> _M_clone_node(_Const_Link_type __x)
> {
> _Link_type __tmp = _M_create_node(__x->_M_value_field);
> __tmp->_M_color = __x->_M_color;
> __tmp->_M_left = 0;
> __tmp->_M_right = 0;
> return __tmp;
> }
>
> protected:
> template<typename _Key_compare,
> bool _Is_pod_comparator = __is_pod(_Key_compare)>
> struct _Rb_tree_impl : public _Node_allocator
> {
> _Key_compare _M_key_compare;
> _Rb_tree_node_base _M_header;
> size_type _M_node_count;
>
> _Rb_tree_impl()
> : _Node_allocator(), _M_key_compare(), _M_header(),
> _M_node_count(0)
> { _M_initialize(); }
>
> _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
> : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
> _M_node_count(0)
> { _M_initialize(); }
>
>
> _Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a)
> : _Node_allocator(std::move(__a)), _M_key_compare(__comp),
> _M_header(), _M_node_count(0)
> { _M_initialize(); }
>
>
> private:
> void
> _M_initialize()
> {
> this->_M_header._M_color = _S_red;
> this->_M_header._M_parent = 0;
> this->_M_header._M_left = &this->_M_header;
> this->_M_header._M_right = &this->_M_header;
> }
> };
>
> _Rb_tree_impl<_Compare> _M_impl;
>
> protected:
> _Base_ptr&
> _M_root()
> { return this->_M_impl._M_header._M_parent; }
>
> _Const_Base_ptr
> _M_root() const
> { return this->_M_impl._M_header._M_parent; }
>
> _Base_ptr&
> _M_leftmost()
> { return this->_M_impl._M_header._M_left; }
>
> _Const_Base_ptr
> _M_leftmost() const
> { return this->_M_impl._M_header._M_left; }
>
> _Base_ptr&
> _M_rightmost()
> { return this->_M_impl._M_header._M_right; }
>
> _Const_Base_ptr
> _M_rightmost() const
> { return this->_M_impl._M_header._M_right; }
>
> _Link_type
> _M_begin()
> { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }
>
> _Const_Link_type
> _M_begin() const
> {
> return static_cast<_Const_Link_type>
> (this->_M_impl._M_header._M_parent);
> }
>
> _Link_type
> _M_end()
> { return static_cast<_Link_type>(&this->_M_impl._M_header); }
>
> _Const_Link_type
> _M_end() const
> { return static_cast<_Const_Link_type>(&this->_M_impl._M_header); }
>
> static const_reference
> _S_value(_Const_Link_type __x)
> { return __x->_M_value_field; }
>
> static const _Key&
> _S_key(_Const_Link_type __x)
> { return _KeyOfValue()(_S_value(__x)); }
>
> static _Link_type
> _S_left(_Base_ptr __x)
> { return static_cast<_Link_type>(__x->_M_left); }
>
> static _Const_Link_type
> _S_left(_Const_Base_ptr __x)
> { return static_cast<_Const_Link_type>(__x->_M_left); }
>
> static _Link_type
> _S_right(_Base_ptr __x)
> { return static_cast<_Link_type>(__x->_M_right); }
>
> static _Const_Link_type
> _S_right(_Const_Base_ptr __x)
> { return static_cast<_Const_Link_type>(__x->_M_right); }
>
> static const_reference
> _S_value(_Const_Base_ptr __x)
> { return static_cast<_Const_Link_type>(__x)->_M_value_field; }
>
> static const _Key&
> _S_key(_Const_Base_ptr __x)
> { return _KeyOfValue()(_S_value(__x)); }
>
> static _Base_ptr
> _S_minimum(_Base_ptr __x)
> { return _Rb_tree_node_base::_S_minimum(__x); }
>
> static _Const_Base_ptr
> _S_minimum(_Const_Base_ptr __x)
> { return _Rb_tree_node_base::_S_minimum(__x); }
>
> static _Base_ptr
> _S_maximum(_Base_ptr __x)
> { return _Rb_tree_node_base::_S_maximum(__x); }
>
> static _Const_Base_ptr
> _S_maximum(_Const_Base_ptr __x)
> { return _Rb_tree_node_base::_S_maximum(__x); }
>
> public:
> typedef _Rb_tree_iterator<value_type> iterator;
> typedef _Rb_tree_const_iterator<value_type> const_iterator;
>
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
>
> private:
> pair<_Base_ptr, _Base_ptr>
> _M_get_insert_unique_pos(const key_type& __k);
>
> pair<_Base_ptr, _Base_ptr>
> _M_get_insert_equal_pos(const key_type& __k);
>
> pair<_Base_ptr, _Base_ptr>
> _M_get_insert_hint_unique_pos(const_iterator __pos,
> const key_type& __k);
>
> pair<_Base_ptr, _Base_ptr>
> _M_get_insert_hint_equal_pos(const_iterator __pos,
> const key_type& __k);
>
>
> template<typename _Arg>
> iterator
> _M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v);
>
> iterator
> _M_insert_node(_Base_ptr __x, _Base_ptr __y, _Link_type __z);
>
> template<typename _Arg>
> iterator
> _M_insert_lower(_Base_ptr __y, _Arg&& __v);
>
> template<typename _Arg>
> iterator
> _M_insert_equal_lower(_Arg&& __x);
>
> iterator
> _M_insert_lower_node(_Base_ptr __p, _Link_type __z);
>
> iterator
> _M_insert_equal_lower_node(_Link_type __z);
># 624 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
> _Link_type
> _M_copy(_Const_Link_type __x, _Link_type __p);
>
> void
> _M_erase(_Link_type __x);
>
> iterator
> _M_lower_bound(_Link_type __x, _Link_type __y,
> const _Key& __k);
>
> const_iterator
> _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
> const _Key& __k) const;
>
> iterator
> _M_upper_bound(_Link_type __x, _Link_type __y,
> const _Key& __k);
>
> const_iterator
> _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
> const _Key& __k) const;
>
> public:
>
> _Rb_tree() { }
>
> _Rb_tree(const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_impl(__comp, _Node_allocator(__a)) { }
>
> _Rb_tree(const _Rb_tree& __x)
> : _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
> {
> if (__x._M_root() != 0)
> {
> _M_root() = _M_copy(__x._M_begin(), _M_end());
> _M_leftmost() = _S_minimum(_M_root());
> _M_rightmost() = _S_maximum(_M_root());
> _M_impl._M_node_count = __x._M_impl._M_node_count;
> }
> }
>
>
> _Rb_tree(_Rb_tree&& __x);
>
>
> ~_Rb_tree() noexcept
> { _M_erase(_M_begin()); }
>
> _Rb_tree&
> operator=(const _Rb_tree& __x);
>
>
> _Compare
> key_comp() const
> { return _M_impl._M_key_compare; }
>
> iterator
> begin() noexcept
> {
> return iterator(static_cast<_Link_type>
> (this->_M_impl._M_header._M_left));
> }
>
> const_iterator
> begin() const noexcept
> {
> return const_iterator(static_cast<_Const_Link_type>
> (this->_M_impl._M_header._M_left));
> }
>
> iterator
> end() noexcept
> { return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); }
>
> const_iterator
> end() const noexcept
> {
> return const_iterator(static_cast<_Const_Link_type>
> (&this->_M_impl._M_header));
> }
>
> reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(end()); }
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
> reverse_iterator
> rend() noexcept
> { return reverse_iterator(begin()); }
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(begin()); }
>
> bool
> empty() const noexcept
> { return _M_impl._M_node_count == 0; }
>
> size_type
> size() const noexcept
> { return _M_impl._M_node_count; }
>
> size_type
> max_size() const noexcept
> { return _M_get_Node_allocator().max_size(); }
>
> void
> swap(_Rb_tree& __t);
>
>
>
> template<typename _Arg>
> pair<iterator, bool>
> _M_insert_unique(_Arg&& __x);
>
> template<typename _Arg>
> iterator
> _M_insert_equal(_Arg&& __x);
>
> template<typename _Arg>
> iterator
> _M_insert_unique_(const_iterator __position, _Arg&& __x);
>
> template<typename _Arg>
> iterator
> _M_insert_equal_(const_iterator __position, _Arg&& __x);
>
> template<typename... _Args>
> pair<iterator, bool>
> _M_emplace_unique(_Args&&... __args);
>
> template<typename... _Args>
> iterator
> _M_emplace_equal(_Args&&... __args);
>
> template<typename... _Args>
> iterator
> _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args);
>
> template<typename... _Args>
> iterator
> _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args);
># 784 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
> template<typename _InputIterator>
> void
> _M_insert_unique(_InputIterator __first, _InputIterator __last);
>
> template<typename _InputIterator>
> void
> _M_insert_equal(_InputIterator __first, _InputIterator __last);
>
> private:
> void
> _M_erase_aux(const_iterator __position);
>
> void
> _M_erase_aux(const_iterator __first, const_iterator __last);
>
> public:
>
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> iterator
> erase(const_iterator __position)
> {
> const_iterator __result = __position;
> ++__result;
> _M_erase_aux(__position);
> return __result._M_const_cast();
> }
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> iterator
> erase(iterator __position)
> {
> iterator __result = __position;
> ++__result;
> _M_erase_aux(__position);
> return __result;
> }
># 832 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
> size_type
> erase(const key_type& __x);
>
>
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> iterator
> erase(const_iterator __first, const_iterator __last)
> {
> _M_erase_aux(__first, __last);
> return __last._M_const_cast();
> }
># 854 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
> void
> erase(const key_type* __first, const key_type* __last);
>
> void
> clear() noexcept
> {
> _M_erase(_M_begin());
> _M_leftmost() = _M_end();
> _M_root() = 0;
> _M_rightmost() = _M_end();
> _M_impl._M_node_count = 0;
> }
>
>
> iterator
> find(const key_type& __k);
>
> const_iterator
> find(const key_type& __k) const;
>
> size_type
> count(const key_type& __k) const;
>
> iterator
> lower_bound(const key_type& __k)
> { return _M_lower_bound(_M_begin(), _M_end(), __k); }
>
> const_iterator
> lower_bound(const key_type& __k) const
> { return _M_lower_bound(_M_begin(), _M_end(), __k); }
>
> iterator
> upper_bound(const key_type& __k)
> { return _M_upper_bound(_M_begin(), _M_end(), __k); }
>
> const_iterator
> upper_bound(const key_type& __k) const
> { return _M_upper_bound(_M_begin(), _M_end(), __k); }
>
> pair<iterator, iterator>
> equal_range(const key_type& __k);
>
> pair<const_iterator, const_iterator>
> equal_range(const key_type& __k) const;
>
>
> bool
> __rb_verify() const;
> };
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> {
> return __x.size() == __y.size()
> && std::equal(__x.begin(), __x.end(), __y.begin());
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> {
> return std::lexicographical_compare(__x.begin(), __x.end(),
> __y.begin(), __y.end());
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> { return !(__x == __y); }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> { return __y < __x; }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> { return !(__y < __x); }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> { return !(__x < __y); }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline void
> swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> { __x.swap(__y); }
>
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _Rb_tree(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&& __x)
> : _M_impl(__x._M_impl._M_key_compare,
> std::move(__x._M_get_Node_allocator()))
> {
> if (__x._M_root() != 0)
> {
> _M_root() = __x._M_root();
> _M_leftmost() = __x._M_leftmost();
> _M_rightmost() = __x._M_rightmost();
> _M_root()->_M_parent = _M_end();
>
> __x._M_root() = 0;
> __x._M_leftmost() = __x._M_end();
> __x._M_rightmost() = __x._M_end();
>
> this->_M_impl._M_node_count = __x._M_impl._M_node_count;
> __x._M_impl._M_node_count = 0;
> }
> }
>
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> operator=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x)
> {
> if (this != &__x)
> {
>
> clear();
> _M_impl._M_key_compare = __x._M_impl._M_key_compare;
> if (__x._M_root() != 0)
> {
> _M_root() = _M_copy(__x._M_begin(), _M_end());
> _M_leftmost() = _S_minimum(_M_root());
> _M_rightmost() = _S_maximum(_M_root());
> _M_impl._M_node_count = __x._M_impl._M_node_count;
> }
> }
> return *this;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
>
> template<typename _Arg>
>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
> _M_insert_(_Base_ptr __x, _Base_ptr __p, _Arg&& __v)
>
>
>
> {
> bool __insert_left = (__x != 0 || __p == _M_end()
> || _M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key(__p)));
>
> _Link_type __z = _M_create_node(std::forward<_Arg>(__v));
>
> _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
> this->_M_impl._M_header);
> ++_M_impl._M_node_count;
> return iterator(__z);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
>
> template<typename _Arg>
>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
> _M_insert_lower(_Base_ptr __p, _Arg&& __v)
>
>
>
> {
> bool __insert_left = (__p == _M_end()
> || !_M_impl._M_key_compare(_S_key(__p),
> _KeyOfValue()(__v)));
>
> _Link_type __z = _M_create_node(std::forward<_Arg>(__v));
>
> _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
> this->_M_impl._M_header);
> ++_M_impl._M_node_count;
> return iterator(__z);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
>
> template<typename _Arg>
>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
> _M_insert_equal_lower(_Arg&& __v)
>
>
>
> {
> _Link_type __x = _M_begin();
> _Link_type __y = _M_end();
> while (__x != 0)
> {
> __y = __x;
> __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
> _S_left(__x) : _S_right(__x);
> }
> return _M_insert_lower(__y, std::forward<_Arg>(__v));
> }
>
> template<typename _Key, typename _Val, typename _KoV,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
> _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
> _M_copy(_Const_Link_type __x, _Link_type __p)
> {
>
> _Link_type __top = _M_clone_node(__x);
> __top->_M_parent = __p;
>
> try
> {
> if (__x->_M_right)
> __top->_M_right = _M_copy(_S_right(__x), __top);
> __p = __top;
> __x = _S_left(__x);
>
> while (__x != 0)
> {
> _Link_type __y = _M_clone_node(__x);
> __p->_M_left = __y;
> __y->_M_parent = __p;
> if (__x->_M_right)
> __y->_M_right = _M_copy(_S_right(__x), __y);
> __p = __y;
> __x = _S_left(__x);
> }
> }
> catch(...)
> {
> _M_erase(__top);
> throw;
> }
> return __top;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_erase(_Link_type __x)
> {
>
> while (__x != 0)
> {
> _M_erase(_S_right(__x));
> _Link_type __y = _S_left(__x);
> _M_destroy_node(__x);
> __x = __y;
> }
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_lower_bound(_Link_type __x, _Link_type __y,
> const _Key& __k)
> {
> while (__x != 0)
> if (!_M_impl._M_key_compare(_S_key(__x), __k))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
> return iterator(__y);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::const_iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
> const _Key& __k) const
> {
> while (__x != 0)
> if (!_M_impl._M_key_compare(_S_key(__x), __k))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
> return const_iterator(__y);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_upper_bound(_Link_type __x, _Link_type __y,
> const _Key& __k)
> {
> while (__x != 0)
> if (_M_impl._M_key_compare(__k, _S_key(__x)))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
> return iterator(__y);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::const_iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
> const _Key& __k) const
> {
> while (__x != 0)
> if (_M_impl._M_key_compare(__k, _S_key(__x)))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
> return const_iterator(__y);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator,
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> equal_range(const _Key& __k)
> {
> _Link_type __x = _M_begin();
> _Link_type __y = _M_end();
> while (__x != 0)
> {
> if (_M_impl._M_key_compare(_S_key(__x), __k))
> __x = _S_right(__x);
> else if (_M_impl._M_key_compare(__k, _S_key(__x)))
> __y = __x, __x = _S_left(__x);
> else
> {
> _Link_type __xu(__x), __yu(__y);
> __y = __x, __x = _S_left(__x);
> __xu = _S_right(__xu);
> return pair<iterator,
> iterator>(_M_lower_bound(__x, __y, __k),
> _M_upper_bound(__xu, __yu, __k));
> }
> }
> return pair<iterator, iterator>(iterator(__y),
> iterator(__y));
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::const_iterator,
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::const_iterator>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> equal_range(const _Key& __k) const
> {
> _Const_Link_type __x = _M_begin();
> _Const_Link_type __y = _M_end();
> while (__x != 0)
> {
> if (_M_impl._M_key_compare(_S_key(__x), __k))
> __x = _S_right(__x);
> else if (_M_impl._M_key_compare(__k, _S_key(__x)))
> __y = __x, __x = _S_left(__x);
> else
> {
> _Const_Link_type __xu(__x), __yu(__y);
> __y = __x, __x = _S_left(__x);
> __xu = _S_right(__xu);
> return pair<const_iterator,
> const_iterator>(_M_lower_bound(__x, __y, __k),
> _M_upper_bound(__xu, __yu, __k));
> }
> }
> return pair<const_iterator, const_iterator>(const_iterator(__y),
> const_iterator(__y));
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
> {
> if (_M_root() == 0)
> {
> if (__t._M_root() != 0)
> {
> _M_root() = __t._M_root();
> _M_leftmost() = __t._M_leftmost();
> _M_rightmost() = __t._M_rightmost();
> _M_root()->_M_parent = _M_end();
>
> __t._M_root() = 0;
> __t._M_leftmost() = __t._M_end();
> __t._M_rightmost() = __t._M_end();
> }
> }
> else if (__t._M_root() == 0)
> {
> __t._M_root() = _M_root();
> __t._M_leftmost() = _M_leftmost();
> __t._M_rightmost() = _M_rightmost();
> __t._M_root()->_M_parent = __t._M_end();
>
> _M_root() = 0;
> _M_leftmost() = _M_end();
> _M_rightmost() = _M_end();
> }
> else
> {
> std::swap(_M_root(),__t._M_root());
> std::swap(_M_leftmost(),__t._M_leftmost());
> std::swap(_M_rightmost(),__t._M_rightmost());
>
> _M_root()->_M_parent = _M_end();
> __t._M_root()->_M_parent = __t._M_end();
> }
>
> std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
> std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);
>
>
>
> std::__alloc_swap<_Node_allocator>::
> _S_do_it(_M_get_Node_allocator(), __t._M_get_Node_allocator());
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr,
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_get_insert_unique_pos(const key_type& __k)
> {
> typedef pair<_Base_ptr, _Base_ptr> _Res;
> _Link_type __x = _M_begin();
> _Link_type __y = _M_end();
> bool __comp = true;
> while (__x != 0)
> {
> __y = __x;
> __comp = _M_impl._M_key_compare(__k, _S_key(__x));
> __x = __comp ? _S_left(__x) : _S_right(__x);
> }
> iterator __j = iterator(__y);
> if (__comp)
> {
> if (__j == begin())
> return _Res(__x, __y);
> else
> --__j;
> }
> if (_M_impl._M_key_compare(_S_key(__j._M_node), __k))
> return _Res(__x, __y);
> return _Res(__j._M_node, 0);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr,
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_get_insert_equal_pos(const key_type& __k)
> {
> typedef pair<_Base_ptr, _Base_ptr> _Res;
> _Link_type __x = _M_begin();
> _Link_type __y = _M_end();
> while (__x != 0)
> {
> __y = __x;
> __x = _M_impl._M_key_compare(__k, _S_key(__x)) ?
> _S_left(__x) : _S_right(__x);
> }
> return _Res(__x, __y);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
>
> template<typename _Arg>
>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator, bool>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
> _M_insert_unique(_Arg&& __v)
>
>
>
> {
> typedef pair<iterator, bool> _Res;
> pair<_Base_ptr, _Base_ptr> __res
> = _M_get_insert_unique_pos(_KeyOfValue()(__v));
>
> if (__res.second)
> return _Res(_M_insert_(__res.first, __res.second,
> std::forward<_Arg>(__v)),
> true);
>
> return _Res(iterator(static_cast<_Link_type>(__res.first)), false);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
>
> template<typename _Arg>
>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
> _M_insert_equal(_Arg&& __v)
>
>
>
> {
> pair<_Base_ptr, _Base_ptr> __res
> = _M_get_insert_equal_pos(_KeyOfValue()(__v));
> return _M_insert_(__res.first, __res.second, std::forward<_Arg>(__v));
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr,
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_get_insert_hint_unique_pos(const_iterator __position,
> const key_type& __k)
> {
> iterator __pos = __position._M_const_cast();
> typedef pair<_Base_ptr, _Base_ptr> _Res;
>
>
> if (__pos._M_node == _M_end())
> {
> if (size() > 0
> && _M_impl._M_key_compare(_S_key(_M_rightmost()), __k))
> return _Res(0, _M_rightmost());
> else
> return _M_get_insert_unique_pos(__k);
> }
> else if (_M_impl._M_key_compare(__k, _S_key(__pos._M_node)))
> {
>
> iterator __before = __pos;
> if (__pos._M_node == _M_leftmost())
> return _Res(_M_leftmost(), _M_leftmost());
> else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), __k))
> {
> if (_S_right(__before._M_node) == 0)
> return _Res(0, __before._M_node);
> else
> return _Res(__pos._M_node, __pos._M_node);
> }
> else
> return _M_get_insert_unique_pos(__k);
> }
> else if (_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
> {
>
> iterator __after = __pos;
> if (__pos._M_node == _M_rightmost())
> return _Res(0, _M_rightmost());
> else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node)))
> {
> if (_S_right(__pos._M_node) == 0)
> return _Res(0, __pos._M_node);
> else
> return _Res(__after._M_node, __after._M_node);
> }
> else
> return _M_get_insert_unique_pos(__k);
> }
> else
>
> return _Res(__pos._M_node, 0);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
>
> template<typename _Arg>
>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
> _M_insert_unique_(const_iterator __position, _Arg&& __v)
>
>
>
> {
> pair<_Base_ptr, _Base_ptr> __res
> = _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v));
>
> if (__res.second)
> return _M_insert_(__res.first, __res.second,
> std::forward<_Arg>(__v));
> return iterator(static_cast<_Link_type>(__res.first));
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr,
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_get_insert_hint_equal_pos(const_iterator __position, const key_type& __k)
> {
> iterator __pos = __position._M_const_cast();
> typedef pair<_Base_ptr, _Base_ptr> _Res;
>
>
> if (__pos._M_node == _M_end())
> {
> if (size() > 0
> && !_M_impl._M_key_compare(__k, _S_key(_M_rightmost())))
> return _Res(0, _M_rightmost());
> else
> return _M_get_insert_equal_pos(__k);
> }
> else if (!_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
> {
>
> iterator __before = __pos;
> if (__pos._M_node == _M_leftmost())
> return _Res(_M_leftmost(), _M_leftmost());
> else if (!_M_impl._M_key_compare(__k, _S_key((--__before)._M_node)))
> {
> if (_S_right(__before._M_node) == 0)
> return _Res(0, __before._M_node);
> else
> return _Res(__pos._M_node, __pos._M_node);
> }
> else
> return _M_get_insert_equal_pos(__k);
> }
> else
> {
>
> iterator __after = __pos;
> if (__pos._M_node == _M_rightmost())
> return _Res(0, _M_rightmost());
> else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k))
> {
> if (_S_right(__pos._M_node) == 0)
> return _Res(0, __pos._M_node);
> else
> return _Res(__after._M_node, __after._M_node);
> }
> else
> return _Res(0, 0);
> }
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
>
> template<typename _Arg>
>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
> _M_insert_equal_(const_iterator __position, _Arg&& __v)
>
>
>
> {
> pair<_Base_ptr, _Base_ptr> __res
> = _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v));
>
> if (__res.second)
> return _M_insert_(__res.first, __res.second,
> std::forward<_Arg>(__v));
>
> return _M_insert_equal_lower(std::forward<_Arg>(__v));
> }
>
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_insert_node(_Base_ptr __x, _Base_ptr __p, _Link_type __z)
> {
> bool __insert_left = (__x != 0 || __p == _M_end()
> || _M_impl._M_key_compare(_S_key(__z),
> _S_key(__p)));
>
> _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
> this->_M_impl._M_header);
> ++_M_impl._M_node_count;
> return iterator(__z);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_insert_lower_node(_Base_ptr __p, _Link_type __z)
> {
> bool __insert_left = (__p == _M_end()
> || !_M_impl._M_key_compare(_S_key(__p),
> _S_key(__z)));
>
> _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
> this->_M_impl._M_header);
> ++_M_impl._M_node_count;
> return iterator(__z);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_insert_equal_lower_node(_Link_type __z)
> {
> _Link_type __x = _M_begin();
> _Link_type __y = _M_end();
> while (__x != 0)
> {
> __y = __x;
> __x = !_M_impl._M_key_compare(_S_key(__x), _S_key(__z)) ?
> _S_left(__x) : _S_right(__x);
> }
> return _M_insert_lower_node(__y, __z);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> template<typename... _Args>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator, bool>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_emplace_unique(_Args&&... __args)
> {
> _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
>
> try
> {
> typedef pair<iterator, bool> _Res;
> auto __res = _M_get_insert_unique_pos(_S_key(__z));
> if (__res.second)
> return _Res(_M_insert_node(__res.first, __res.second, __z), true);
>
> _M_destroy_node(__z);
> return _Res(iterator(static_cast<_Link_type>(__res.first)), false);
> }
> catch(...)
> {
> _M_destroy_node(__z);
> throw;
> }
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> template<typename... _Args>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_emplace_equal(_Args&&... __args)
> {
> _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
>
> try
> {
> auto __res = _M_get_insert_equal_pos(_S_key(__z));
> return _M_insert_node(__res.first, __res.second, __z);
> }
> catch(...)
> {
> _M_destroy_node(__z);
> throw;
> }
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> template<typename... _Args>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args)
> {
> _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
>
> try
> {
> auto __res = _M_get_insert_hint_unique_pos(__pos, _S_key(__z));
>
> if (__res.second)
> return _M_insert_node(__res.first, __res.second, __z);
>
> _M_destroy_node(__z);
> return iterator(static_cast<_Link_type>(__res.first));
> }
> catch(...)
> {
> _M_destroy_node(__z);
> throw;
> }
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> template<typename... _Args>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args)
> {
> _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
>
> try
> {
> auto __res = _M_get_insert_hint_equal_pos(__pos, _S_key(__z));
>
> if (__res.second)
> return _M_insert_node(__res.first, __res.second, __z);
>
> return _M_insert_equal_lower_node(__z);
> }
> catch(...)
> {
> _M_destroy_node(__z);
> throw;
> }
> }
>
>
> template<typename _Key, typename _Val, typename _KoV,
> typename _Cmp, typename _Alloc>
> template<class _II>
> void
> _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
> _M_insert_unique(_II __first, _II __last)
> {
> for (; __first != __last; ++__first)
> _M_insert_unique_(end(), *__first);
> }
>
> template<typename _Key, typename _Val, typename _KoV,
> typename _Cmp, typename _Alloc>
> template<class _II>
> void
> _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
> _M_insert_equal(_II __first, _II __last)
> {
> for (; __first != __last; ++__first)
> _M_insert_equal_(end(), *__first);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_erase_aux(const_iterator __position)
> {
> _Link_type __y =
> static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
> (const_cast<_Base_ptr>(__position._M_node),
> this->_M_impl._M_header));
> _M_destroy_node(__y);
> --_M_impl._M_node_count;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_erase_aux(const_iterator __first, const_iterator __last)
> {
> if (__first == begin() && __last == end())
> clear();
> else
> while (__first != __last)
> erase(__first++);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> erase(const _Key& __x)
> {
> pair<iterator, iterator> __p = equal_range(__x);
> const size_type __old_size = size();
> erase(__p.first, __p.second);
> return __old_size - size();
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> erase(const _Key* __first, const _Key* __last)
> {
> while (__first != __last)
> erase(*__first++);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> find(const _Key& __k)
> {
> iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
> return (__j == end()
> || _M_impl._M_key_compare(__k,
> _S_key(__j._M_node))) ? end() : __j;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::const_iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> find(const _Key& __k) const
> {
> const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
> return (__j == end()
> || _M_impl._M_key_compare(__k,
> _S_key(__j._M_node))) ? end() : __j;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> count(const _Key& __k) const
> {
> pair<const_iterator, const_iterator> __p = equal_range(__k);
> const size_type __n = std::distance(__p.first, __p.second);
> return __n;
> }
>
> __attribute__ ((__pure__)) unsigned int
> _Rb_tree_black_count(const _Rb_tree_node_base* __node,
> const _Rb_tree_node_base* __root) throw ();
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> bool
> _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
> {
> if (_M_impl._M_node_count == 0 || begin() == end())
> return _M_impl._M_node_count == 0 && begin() == end()
> && this->_M_impl._M_header._M_left == _M_end()
> && this->_M_impl._M_header._M_right == _M_end();
>
> unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
> for (const_iterator __it = begin(); __it != end(); ++__it)
> {
> _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node);
> _Const_Link_type __L = _S_left(__x);
> _Const_Link_type __R = _S_right(__x);
>
> if (__x->_M_color == _S_red)
> if ((__L && __L->_M_color == _S_red)
> || (__R && __R->_M_color == _S_red))
> return false;
>
> if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L)))
> return false;
> if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x)))
> return false;
>
> if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
> return false;
> }
>
> if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
> return false;
> if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
> return false;
> return true;
> }
>
>
>}
># 61 "/usr/include/c++/4.8.2/map" 2 3
># 1 "/usr/include/c++/4.8.2/bits/stl_map.h" 1 3
># 66 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 94 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
> typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
> class map
> {
> public:
> typedef _Key key_type;
> typedef _Tp mapped_type;
> typedef std::pair<const _Key, _Tp> value_type;
> typedef _Compare key_compare;
> typedef _Alloc allocator_type;
>
> private:
>
> typedef typename _Alloc::value_type _Alloc_value_type;
> 
> 
>
> 
>
> public:
> class value_compare
> : public std::binary_function<value_type, value_type, bool>
> {
> friend class map<_Key, _Tp, _Compare, _Alloc>;
> protected:
> _Compare comp;
>
> value_compare(_Compare __c)
> : comp(__c) { }
>
> public:
> bool operator()(const value_type& __x, const value_type& __y) const
> { return comp(__x.first, __y.first); }
> };
>
> private:
>
> typedef typename _Alloc::template rebind<value_type>::other
> _Pair_alloc_type;
>
> typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
> key_compare, _Pair_alloc_type> _Rep_type;
>
>
> _Rep_type _M_t;
>
> public:
>
>
> typedef typename _Pair_alloc_type::pointer pointer;
> typedef typename _Pair_alloc_type::const_pointer const_pointer;
> typedef typename _Pair_alloc_type::reference reference;
> typedef typename _Pair_alloc_type::const_reference const_reference;
> typedef typename _Rep_type::iterator iterator;
> typedef typename _Rep_type::const_iterator const_iterator;
> typedef typename _Rep_type::size_type size_type;
> typedef typename _Rep_type::difference_type difference_type;
> typedef typename _Rep_type::reverse_iterator reverse_iterator;
> typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
>
>
>
>
>
>
>
> map()
> : _M_t() { }
>
>
>
>
>
>
> explicit
> map(const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Pair_alloc_type(__a)) { }
># 180 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> map(const map& __x)
> : _M_t(__x._M_t) { }
># 191 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> map(map&& __x)
> noexcept(is_nothrow_copy_constructible<_Compare>::value)
> : _M_t(std::move(__x._M_t)) { }
># 206 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> map(initializer_list<value_type> __l,
> const _Compare& __comp = _Compare(),
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Pair_alloc_type(__a))
> { _M_t._M_insert_unique(__l.begin(), __l.end()); }
># 223 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> template<typename _InputIterator>
> map(_InputIterator __first, _InputIterator __last)
> : _M_t()
> { _M_t._M_insert_unique(__first, __last); }
># 240 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> template<typename _InputIterator>
> map(_InputIterator __first, _InputIterator __last,
> const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Pair_alloc_type(__a))
> { _M_t._M_insert_unique(__first, __last); }
># 263 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> map&
> operator=(const map& __x)
> {
> _M_t = __x._M_t;
> return *this;
> }
># 278 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> map&
> operator=(map&& __x)
> {
>
>
> this->clear();
> this->swap(__x);
> return *this;
> }
># 299 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> map&
> operator=(initializer_list<value_type> __l)
> {
> this->clear();
> this->insert(__l.begin(), __l.end());
> return *this;
> }
>
>
>
> allocator_type
> get_allocator() const noexcept
> { return allocator_type(_M_t.get_allocator()); }
>
>
>
>
>
>
>
> iterator
> begin() noexcept
> { return _M_t.begin(); }
>
>
>
>
>
>
> const_iterator
> begin() const noexcept
> { return _M_t.begin(); }
>
>
>
>
>
>
> iterator
> end() noexcept
> { return _M_t.end(); }
>
>
>
>
>
>
> const_iterator
> end() const noexcept
> { return _M_t.end(); }
>
>
>
>
>
>
> reverse_iterator
> rbegin() noexcept
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const noexcept
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> reverse_iterator
> rend() noexcept
> { return _M_t.rend(); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const noexcept
> { return _M_t.rend(); }
>
>
>
>
>
>
>
> const_iterator
> cbegin() const noexcept
> { return _M_t.begin(); }
>
>
>
>
>
>
> const_iterator
> cend() const noexcept
> { return _M_t.end(); }
>
>
>
>
>
>
> const_reverse_iterator
> crbegin() const noexcept
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> const_reverse_iterator
> crend() const noexcept
> { return _M_t.rend(); }
>
>
>
>
>
>
> bool
> empty() const noexcept
> { return _M_t.empty(); }
>
>
> size_type
> size() const noexcept
> { return _M_t.size(); }
>
>
> size_type
> max_size() const noexcept
> { return _M_t.max_size(); }
># 455 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> mapped_type&
> operator[](const key_type& __k)
> {
>
>
>
> iterator __i = lower_bound(__k);
>
> if (__i == end() || key_comp()(__k, (*__i).first))
>
> __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
> std::tuple<const key_type&>(__k),
> std::tuple<>());
>
>
>
> return (*__i).second;
> }
>
>
> mapped_type&
> operator[](key_type&& __k)
> {
>
>
>
> iterator __i = lower_bound(__k);
>
> if (__i == end() || key_comp()(__k, (*__i).first))
> __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
> std::forward_as_tuple(std::move(__k)),
> std::tuple<>());
> return (*__i).second;
> }
># 500 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> mapped_type&
> at(const key_type& __k)
> {
> iterator __i = lower_bound(__k);
> if (__i == end() || key_comp()(__k, (*__i).first))
> __throw_out_of_range(("map::at"));
> return (*__i).second;
> }
>
> const mapped_type&
> at(const key_type& __k) const
> {
> const_iterator __i = lower_bound(__k);
> if (__i == end() || key_comp()(__k, (*__i).first))
> __throw_out_of_range(("map::at"));
> return (*__i).second;
> }
># 538 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> template<typename... _Args>
> std::pair<iterator, bool>
> emplace(_Args&&... __args)
> { return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); }
># 568 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> template<typename... _Args>
> iterator
> emplace_hint(const_iterator __pos, _Args&&... __args)
> {
> return _M_t._M_emplace_hint_unique(__pos,
> std::forward<_Args>(__args)...);
> }
># 593 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> std::pair<iterator, bool>
> insert(const value_type& __x)
> { return _M_t._M_insert_unique(__x); }
>
>
> template<typename _Pair, typename = typename
> std::enable_if<std::is_constructible<value_type,
> _Pair&&>::value>::type>
> std::pair<iterator, bool>
> insert(_Pair&& __x)
> { return _M_t._M_insert_unique(std::forward<_Pair>(__x)); }
># 614 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> void
> insert(std::initializer_list<value_type> __list)
> { insert(__list.begin(), __list.end()); }
># 642 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> iterator
>
> insert(const_iterator __position, const value_type& __x)
>
>
>
> { return _M_t._M_insert_unique_(__position, __x); }
>
>
> template<typename _Pair, typename = typename
> std::enable_if<std::is_constructible<value_type,
> _Pair&&>::value>::type>
> iterator
> insert(const_iterator __position, _Pair&& __x)
> { return _M_t._M_insert_unique_(__position,
> std::forward<_Pair>(__x)); }
># 668 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> template<typename _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_t._M_insert_unique(__first, __last); }
># 689 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> iterator
> erase(const_iterator __position)
> { return _M_t.erase(__position); }
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> iterator
> erase(iterator __position)
> { return _M_t.erase(__position); }
># 725 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> size_type
> erase(const key_type& __x)
> { return _M_t.erase(__x); }
># 745 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> iterator
> erase(const_iterator __first, const_iterator __last)
> { return _M_t.erase(__first, __last); }
># 777 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> void
> swap(map& __x)
> { _M_t.swap(__x._M_t); }
>
>
>
>
>
>
>
> void
> clear() noexcept
> { _M_t.clear(); }
>
>
>
>
>
>
> key_compare
> key_comp() const
> { return _M_t.key_comp(); }
>
>
>
>
>
> value_compare
> value_comp() const
> { return value_compare(_M_t.key_comp()); }
># 820 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> iterator
> find(const key_type& __x)
> { return _M_t.find(__x); }
># 835 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> const_iterator
> find(const key_type& __x) const
> { return _M_t.find(__x); }
># 847 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> size_type
> count(const key_type& __x) const
> { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
># 862 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> iterator
> lower_bound(const key_type& __x)
> { return _M_t.lower_bound(__x); }
># 877 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> const_iterator
> lower_bound(const key_type& __x) const
> { return _M_t.lower_bound(__x); }
>
>
>
>
>
>
>
> iterator
> upper_bound(const key_type& __x)
> { return _M_t.upper_bound(__x); }
>
>
>
>
>
>
>
> const_iterator
> upper_bound(const key_type& __x) const
> { return _M_t.upper_bound(__x); }
># 916 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> std::pair<iterator, iterator>
> equal_range(const key_type& __x)
> { return _M_t.equal_range(__x); }
># 935 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> std::pair<const_iterator, const_iterator>
> equal_range(const key_type& __x) const
> { return _M_t.equal_range(__x); }
>
> template<typename _K1, typename _T1, typename _C1, typename _A1>
> friend bool
> operator==(const map<_K1, _T1, _C1, _A1>&,
> const map<_K1, _T1, _C1, _A1>&);
>
> template<typename _K1, typename _T1, typename _C1, typename _A1>
> friend bool
> operator<(const map<_K1, _T1, _C1, _A1>&,
> const map<_K1, _T1, _C1, _A1>&);
> };
># 960 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __x._M_t == __y._M_t; }
># 977 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __x._M_t < __y._M_t; }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __y < __x; }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline void
> swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
> map<_Key, _Tp, _Compare, _Alloc>& __y)
> { __x.swap(__y); }
>
>
>}
># 62 "/usr/include/c++/4.8.2/map" 2 3
># 1 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 1 3
># 64 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 92 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> template <typename _Key, typename _Tp,
> typename _Compare = std::less<_Key>,
> typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
> class multimap
> {
> public:
> typedef _Key key_type;
> typedef _Tp mapped_type;
> typedef std::pair<const _Key, _Tp> value_type;
> typedef _Compare key_compare;
> typedef _Alloc allocator_type;
>
> private:
>
> typedef typename _Alloc::value_type _Alloc_value_type;
> 
> 
>
> 
>
> public:
> class value_compare
> : public std::binary_function<value_type, value_type, bool>
> {
> friend class multimap<_Key, _Tp, _Compare, _Alloc>;
> protected:
> _Compare comp;
>
> value_compare(_Compare __c)
> : comp(__c) { }
>
> public:
> bool operator()(const value_type& __x, const value_type& __y) const
> { return comp(__x.first, __y.first); }
> };
>
> private:
>
> typedef typename _Alloc::template rebind<value_type>::other
> _Pair_alloc_type;
>
> typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
> key_compare, _Pair_alloc_type> _Rep_type;
>
> _Rep_type _M_t;
>
> public:
>
>
> typedef typename _Pair_alloc_type::pointer pointer;
> typedef typename _Pair_alloc_type::const_pointer const_pointer;
> typedef typename _Pair_alloc_type::reference reference;
> typedef typename _Pair_alloc_type::const_reference const_reference;
> typedef typename _Rep_type::iterator iterator;
> typedef typename _Rep_type::const_iterator const_iterator;
> typedef typename _Rep_type::size_type size_type;
> typedef typename _Rep_type::difference_type difference_type;
> typedef typename _Rep_type::reverse_iterator reverse_iterator;
> typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
>
>
>
>
>
>
> multimap()
> : _M_t() { }
>
>
>
>
>
>
> explicit
> multimap(const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Pair_alloc_type(__a)) { }
># 177 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> multimap(const multimap& __x)
> : _M_t(__x._M_t) { }
># 188 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> multimap(multimap&& __x)
> noexcept(is_nothrow_copy_constructible<_Compare>::value)
> : _M_t(std::move(__x._M_t)) { }
># 202 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> multimap(initializer_list<value_type> __l,
> const _Compare& __comp = _Compare(),
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Pair_alloc_type(__a))
> { _M_t._M_insert_equal(__l.begin(), __l.end()); }
># 218 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> template<typename _InputIterator>
> multimap(_InputIterator __first, _InputIterator __last)
> : _M_t()
> { _M_t._M_insert_equal(__first, __last); }
># 234 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> template<typename _InputIterator>
> multimap(_InputIterator __first, _InputIterator __last,
> const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Pair_alloc_type(__a))
> { _M_t._M_insert_equal(__first, __last); }
># 257 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> multimap&
> operator=(const multimap& __x)
> {
> _M_t = __x._M_t;
> return *this;
> }
># 272 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> multimap&
> operator=(multimap&& __x)
> {
>
>
> this->clear();
> this->swap(__x);
> return *this;
> }
># 293 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> multimap&
> operator=(initializer_list<value_type> __l)
> {
> this->clear();
> this->insert(__l.begin(), __l.end());
> return *this;
> }
>
>
>
> allocator_type
> get_allocator() const noexcept
> { return allocator_type(_M_t.get_allocator()); }
>
>
>
>
>
>
>
> iterator
> begin() noexcept
> { return _M_t.begin(); }
>
>
>
>
>
>
> const_iterator
> begin() const noexcept
> { return _M_t.begin(); }
>
>
>
>
>
>
> iterator
> end() noexcept
> { return _M_t.end(); }
>
>
>
>
>
>
> const_iterator
> end() const noexcept
> { return _M_t.end(); }
>
>
>
>
>
>
> reverse_iterator
> rbegin() noexcept
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const noexcept
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> reverse_iterator
> rend() noexcept
> { return _M_t.rend(); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const noexcept
> { return _M_t.rend(); }
>
>
>
>
>
>
>
> const_iterator
> cbegin() const noexcept
> { return _M_t.begin(); }
>
>
>
>
>
>
> const_iterator
> cend() const noexcept
> { return _M_t.end(); }
>
>
>
>
>
>
> const_reverse_iterator
> crbegin() const noexcept
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> const_reverse_iterator
> crend() const noexcept
> { return _M_t.rend(); }
>
>
>
>
> bool
> empty() const noexcept
> { return _M_t.empty(); }
>
>
> size_type
> size() const noexcept
> { return _M_t.size(); }
>
>
> size_type
> max_size() const noexcept
> { return _M_t.max_size(); }
># 452 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> template<typename... _Args>
> iterator
> emplace(_Args&&... __args)
> { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
># 479 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> template<typename... _Args>
> iterator
> emplace_hint(const_iterator __pos, _Args&&... __args)
> {
> return _M_t._M_emplace_hint_equal(__pos,
> std::forward<_Args>(__args)...);
> }
># 500 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> iterator
> insert(const value_type& __x)
> { return _M_t._M_insert_equal(__x); }
>
>
> template<typename _Pair, typename = typename
> std::enable_if<std::is_constructible<value_type,
> _Pair&&>::value>::type>
> iterator
> insert(_Pair&& __x)
> { return _M_t._M_insert_equal(std::forward<_Pair>(__x)); }
># 533 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> iterator
>
> insert(const_iterator __position, const value_type& __x)
>
>
>
> { return _M_t._M_insert_equal_(__position, __x); }
>
>
> template<typename _Pair, typename = typename
> std::enable_if<std::is_constructible<value_type,
> _Pair&&>::value>::type>
> iterator
> insert(const_iterator __position, _Pair&& __x)
> { return _M_t._M_insert_equal_(__position,
> std::forward<_Pair>(__x)); }
># 560 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> template<typename _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_t._M_insert_equal(__first, __last); }
># 573 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> void
> insert(initializer_list<value_type> __l)
> { this->insert(__l.begin(), __l.end()); }
># 594 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> iterator
> erase(const_iterator __position)
> { return _M_t.erase(__position); }
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> iterator
> erase(iterator __position)
> { return _M_t.erase(__position); }
># 630 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> size_type
> erase(const key_type& __x)
> { return _M_t.erase(__x); }
># 651 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> iterator
> erase(const_iterator __first, const_iterator __last)
> { return _M_t.erase(__first, __last); }
># 686 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> void
> swap(multimap& __x)
> { _M_t.swap(__x._M_t); }
>
>
>
>
>
>
>
> void
> clear() noexcept
> { _M_t.clear(); }
>
>
>
>
>
>
> key_compare
> key_comp() const
> { return _M_t.key_comp(); }
>
>
>
>
>
> value_compare
> value_comp() const
> { return value_compare(_M_t.key_comp()); }
># 729 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> iterator
> find(const key_type& __x)
> { return _M_t.find(__x); }
># 744 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> const_iterator
> find(const key_type& __x) const
> { return _M_t.find(__x); }
>
>
>
>
>
>
> size_type
> count(const key_type& __x) const
> { return _M_t.count(__x); }
># 768 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> iterator
> lower_bound(const key_type& __x)
> { return _M_t.lower_bound(__x); }
># 783 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> const_iterator
> lower_bound(const key_type& __x) const
> { return _M_t.lower_bound(__x); }
>
>
>
>
>
>
>
> iterator
> upper_bound(const key_type& __x)
> { return _M_t.upper_bound(__x); }
>
>
>
>
>
>
>
> const_iterator
> upper_bound(const key_type& __x) const
> { return _M_t.upper_bound(__x); }
># 820 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> std::pair<iterator, iterator>
> equal_range(const key_type& __x)
> { return _M_t.equal_range(__x); }
># 837 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> std::pair<const_iterator, const_iterator>
> equal_range(const key_type& __x) const
> { return _M_t.equal_range(__x); }
>
> template<typename _K1, typename _T1, typename _C1, typename _A1>
> friend bool
> operator==(const multimap<_K1, _T1, _C1, _A1>&,
> const multimap<_K1, _T1, _C1, _A1>&);
>
> template<typename _K1, typename _T1, typename _C1, typename _A1>
> friend bool
> operator<(const multimap<_K1, _T1, _C1, _A1>&,
> const multimap<_K1, _T1, _C1, _A1>&);
> };
># 862 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __x._M_t == __y._M_t; }
># 879 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __x._M_t < __y._M_t; }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __y < __x; }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline void
> swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { __x.swap(__y); }
>
>
>}
># 63 "/usr/include/c++/4.8.2/map" 2 3
># 20 "../src/except.h" 2
>
>
>namespace iwf
>{
>
>
>
> typedef enum e_error_nums
> {
> no_err = 0,
> noNextArgument,
> noParameterValue,
> parameterTooLow,
> parameterTooHigh,
> parameterZero,
> invalidParameterValue,
> unterminatedStringArg,
> incompleteVectorParam,
> undefinedVectorSize,
> filter_too_long,
> invalid_filter_type,
> invalid_debug_level,
> oversample_rate_too_high,
> too_many_repeats,
> cannot_open_file_for_writing,
> tooMuchDecimation,
> oversampleNotInteger,
> wrongType,
> badStringOperation,
> SPIcommunicationFailure,
> tcpCommunicationFailure,
> sampleCountUnmatched,
> noPointsSet,
> noPointDefined,
> setCodeFailed,
> noReferenceData,
> too_many_errors,
> nullWarning = 100,
> captureOverrun,
> saturationWarning,
> cantFindHorizon,
> unrecognisedCommandWarning,
> NoGPIOaccess,
> noHistoryWarning,
> historyVersionWarning,
> historyFailedToWriteTargetWarning,
> targetFailedToReadWarning,
> noCalDataWarning,
> noRefDataWarning,
> refLengthTooLongWarning,
> compressionFailedWarning,
> freeDiskSpaceLowWarning,
> freeDiskSpaceCriticalWarning,
> noValidCalDatalWarning,
> too_many_warnings
> } error_nums;
>
>
>
> typedef enum e_specials
> {
> e_shutdown,
> e_restart,
> e_commsError
> } specials;
>
>
>
> const uint32_t e_specialsStringSize = 256;
> extern char e_specialsErrorString[e_specialsStringSize];
> extern bool e_specialsStringSet;
>
>
>
> class errors_class
> {
> std::map< int, const char * > wildfire_errors;
>
> public:
>
> errors_class();
> ~errors_class();
> std::string operator[](int num)
> {
> return wildfire_errors[num];
> }
> };
>
> extern errors_class errors;
>
>
>
> class error
> {
> public:
> error(error_nums e):number(e){};
> error_nums number;
> };
>
>
>
>
>
> class errorPlus
> {
> public:
> errorPlus(error_nums e, int t):number(e), type(t), string(0) {};
> errorPlus(error_nums e, char * s):number(e), type(0), string(s) {};
> errorPlus(error_nums e, const char * s):number(e), type(0), string(s) {};
> errorPlus(error_nums e, int t, const char * s):number(e), type(t), string(s) {};
> errorPlus(error_nums e, std::string s):number(e), type(0), string(s.c_str()) {};
> error_nums number;
> int type;
> const char *string;
> };
>
> extern const char * unknown_error_string ;
>
>
>
>
>
>
> void warning(std::basic_ostream<char> *stream, error e);
>
>
>
> void warning(std::basic_ostream<char> *stream, errorPlus e);
>
>
>
> void warning(error e);
>
>
>
> void warning(errorPlus e);
>
>}
>
>using namespace iwf;
># 26 "../src/wildfire.h" 2
># 1 "../src/filter.h" 1
># 23 "../src/filter.h"
>enum filterKind
>{
> FIR,
> IIR
>};
>
>enum filterSort
>{
> highPass,
> lowPass,
> bandPass
>};
>
>
>
>struct filterData
>{
> filterData(const filterKind k, const filterSort s, const double g, const int nt, const int nf, const double *t,
> const double *f, const char * n, const double sr, const double pb, const double sb):
> kind(k), sort(s), gain(g), ntaps(nt), taps(t), nfbs(nf), fbs(f), description(n), defSampleRate(sr), defPassBand(pb), defStopBand(sb) {};
>
> const filterKind kind;
> const filterSort sort;
> const double gain;
> const uint32_t ntaps;
> const double *taps;
> const uint32_t nfbs;
> const double *fbs;
> const char *description;
> double defSampleRate;
> double defPassBand;
> double defStopBand;
>};
>
>class filter
>{
>protected:
>
> double invGain;
> boost::circular_buffer<double> inputBuffer;
> uint32_t outputCount;
>
>public:
> filter(const filterData &fd, uint32_t d);
>
> virtual ~filter(void){};
>
> virtual double apply(double input, bool &use) = 0;
>
> void setDecimate(uint32_t d);
> void reset(void);
>
> filterData data;
> uint32_t decimate;
>
>};
>
>class filterIIR: public filter
>{
>protected:
> boost::circular_buffer<double> outputBuffer;
>
>public:
> filterIIR(const filterData &fd, uint32_t d);
> ~filterIIR(void){};
>
> double apply(double input, bool &use);
>};
>
>class filterFIR: public filter
>{
>public:
> filterFIR(const filterData &fd, uint32_t d):filter(fd, d){};
> ~filterFIR(void){};
>
> double apply(double input, bool &use);
>};
>
>
>
>struct filterImplement
>{
>public:
> filterImplement(uint32_t n, uint32_t d):filterNumber(n), decimationFactor(d), itsFilter(0) {};
> uint32_t filterNumber;
> uint32_t decimationFactor;
> filter *itsFilter;
>};
>
>
>
>
>
>
>
>const double filterTaps1[] =
>{
> -0.000088727205720074, 0.000070984327793063, 0.000497221502392527, 0.001505844239503324,
> 0.003431974265765863, 0.006641438252898454, 0.011464718101666764, 0.018119039034800083,
> 0.026628249683059442, 0.036763175632808509, 0.048016437578036870, 0.059625397576471464,
> 0.070645761417258465, 0.080068103555280934, 0.086958656064403866, 0.090599140281067719,
> 0.090599140281067719, 0.086958656064403866, 0.080068103555280934, 0.070645761417258465,
> 0.059625397576471464, 0.048016437578036870, 0.036763175632808509, 0.026628249683059442,
> 0.018119039034800083, 0.011464718101666764, 0.006641438252898454, 0.003431974265765863,
> 0.001505844239503324, 0.000497221502392527, 0.000070984327793063,-0.000088727205720074
>};
>
>const filterData filter1(FIR, lowPass, 1, 32, 0, filterTaps1, 0, "77dB stop, 1.4dB ripple", 250000, 5000, 27000);
>
>
>
>
>
>const double filterTaps2[] =
>{
> -0.000471244902407210, -0.001639304421457866, -0.002989046173953135, -0.002679870224328133,
> 0.001491138623263854, 0.009578017090674415, 0.017189261404095067, 0.016401489527354672,
> 0.001307188203180627, -0.024506426076207580, -0.044744743972282147, -0.036586081720752062,
> 0.015018301181911550, 0.103671380792608110, 0.199260424922394760, 0.261351526304802460,
> 0.261351526304802460, 0.199260424922394760, 0.103671380792608110, 0.015018301181911550,
> -0.036586081720752062, -0.044744743972282147, -0.024506426076207580, 0.001307188203180627,
> 0.016401489527354672, 0.017189261404095067, 0.009578017090674415, 0.001491138623263854,
> -0.002679870224328133, -0.002989046173953135, -0.001639304421457866, -0.000471244902407210
>};
>
>const filterData filter2(FIR, lowPass, 1, 32, 0, filterTaps2, 0, "81dB stop, 0.4dB ripple", 50000, 5000, 10000);
>
>
>
>const filterData filter3(filter2);
>
>
>
>
>
>
>const double filterTaps4 [] =
>{
> +0.0010742270, +0.0013668188, +0.0014604001, +0.0011778449,
> +0.0002972997, -0.0013584038, -0.0037743373, -0.0065842929,
> -0.0089768712, -0.0097505900, -0.0075730052, -0.0014350366,
> +0.0087922257, +0.0218679570, +0.0349675367, +0.0439271066,
> +0.0440327511, +0.0312864079, +0.0039079941, -0.0363058322,
> -0.0831997781, -0.1264232762, -0.1527209161, -0.1482582053,
> -0.1015962385, -0.0066942100, +0.1347820143, +0.3124899081,
> +0.5081703210, +0.6981507673, +0.8571915119, +0.9629302405,
> +0.9999999826, +0.9629302405, +0.8571915119, +0.6981507673,
> +0.5081703210, +0.3124899081, +0.1347820143, -0.0066942100,
> -0.1015962385, -0.1482582053, -0.1527209161, -0.1264232762,
> -0.0831997781, -0.0363058322, +0.0039079941, +0.0312864079,
> +0.0440327511, +0.0439271066, +0.0349675367, +0.0218679570,
> +0.0087922257, -0.0014350366, -0.0075730052, -0.0097505900,
> -0.0089768712, -0.0065842929, -0.0037743373, -0.0013584038,
> +0.0002972997, +0.0011778449, +0.0014604001, +0.0013668188,
> +0.0010742270
>};
>
>const filterData filter4(FIR, lowPass, 6.946444661e+00, 65, 0, filterTaps4, 0, "60dB stop, 0.01dB ripple, linear phase", 250000, 12500, 25000);
>
>
>
>
>
>
>const double filterTaps5 [] =
>{
> -0.0024327388, -0.0029079787, -0.0030290177, -0.0027470206,
> -0.0020411578, -0.0009310446, +0.0005098940, +0.0021446509,
> +0.0037716287, +0.0051368522, +0.0059617279, +0.0059853912,
> +0.0050168437, +0.0029884877, +0.0000001962, -0.0036575356,
> -0.0075110555, -0.0109471862, -0.0132924889, -0.0139205167,
> -0.0123725282, -0.0084718713, -0.0024098652, +0.0052175864,
> +0.0134379369, +0.0210006379, +0.0265409806, +0.0287912466,
> +0.0268102571, +0.0201948867, +0.0092348643, -0.0050237314,
> -0.0208303553, -0.0359053967, -0.0477279006, -0.0539045153,
> -0.0525713213, -0.0427687113, -0.0247262658, -0.0000009855,
> +0.0285717014, +0.0571306155, +0.0812324231, +0.0964430958,
> +0.0990073738, +0.0865074269, +0.0584143575, +0.0164421096,
> -0.0353670751, -0.0908650938, -0.1423282131, -0.1812524691,
> -0.1993319964, -0.1895071562, -0.1469520288, -0.0698703046,
> +0.0400142345, +0.1773531202, +0.3334893368, +0.4971768596,
> +0.6556343555, +0.7958192180, +0.9057770074, +0.9759082535,
> +1.0000015414, +0.9759082535, +0.9057770074, +0.7958192180,
> +0.6556343555, +0.4971768596, +0.3334893368, +0.1773531202,
> +0.0400142345, -0.0698703046, -0.1469520288, -0.1895071562,
> -0.1993319964, -0.1812524691, -0.1423282131, -0.0908650938,
> -0.0353670751, +0.0164421096, +0.0584143575, +0.0865074269,
> +0.0990073738, +0.0964430958, +0.0812324231, +0.0571306155,
> +0.0285717014, -0.0000009855, -0.0247262658, -0.0427687113,
> -0.0525713213, -0.0539045153, -0.0477279006, -0.0359053967,
> -0.0208303553, -0.0050237314, +0.0092348643, +0.0201948867,
> +0.0268102571, +0.0287912466, +0.0265409806, +0.0210006379,
> +0.0134379369, +0.0052175864, -0.0024098652, -0.0084718713,
> -0.0123725282, -0.0139205167, -0.0132924889, -0.0109471862,
> -0.0075110555, -0.0036575356, +0.0000001962, +0.0029884877,
> +0.0050168437, +0.0059853912, +0.0059617279, +0.0051368522,
> +0.0037716287, +0.0021446509, +0.0005098940, -0.0009310446,
> -0.0020411578, -0.0027470206, -0.0030290177, -0.0029079787,
> -0.0024327388,
>};
>
>const filterData filter5(FIR, lowPass, 8.324121606e+00, 129, 0, filterTaps5, 0, "60dB stop, 0.01dB ripple, linear phase", 50000, 2500, 3000);
>
>
>
>
>
>
>const double filterTaps6 [] =
>{
> -0.0024326133, -0.0030288152, -0.0020409718, +0.0005099606,
> +0.0037715052, +0.0059614268, +0.0050164881, -0.0000000138,
> -0.0075109429, -0.0132920215, -0.0123718831, -0.0024093752,
> +0.0134379507, +0.0265404066, +0.0268093018, +0.0092339880,
> -0.0208306634, -0.0477273959, -0.0525701702, -0.0247249991,
> +0.0285724413, +0.0812322153, +0.0990062552, +0.0584128300,
> -0.0353682789, -0.1423284905, -0.1993311797, -0.1469504787,
> +0.0400157951, +0.3334901680, +0.6556340559, +0.9057757084,
> +0.9999998468, +0.9057757084, +0.6556340559, +0.3334901680,
> +0.0400157951, -0.1469504787, -0.1993311797, -0.1423284905,
> -0.0353682789, +0.0584128300, +0.0990062552, +0.0812322153,
> +0.0285724413, -0.0247249991, -0.0525701702, -0.0477273959,
> -0.0208306634, +0.0092339880, +0.0268093018, +0.0265404066,
> +0.0134379507, -0.0024093752, -0.0123718831, -0.0132920215,
> -0.0075109429, -0.0000000138, +0.0050164881, +0.0059614268,
> +0.0037715052, +0.0005099606, -0.0020409718, -0.0030288152,
> -0.0024326133,
>};
>
>const filterData filter6(FIR, lowPass, 4.161004255e+00, 65, 0, filterTaps6, 0, "60dB stop, 0.01dB ripple, linear phase", 50000, 5000, 6000);
># 261 "../src/filter.h"
>const double filterTaps7 [] =
>{ -0.0015820462, -0.0010695625, -0.0005483595, -0.0001524277,
> -0.0000000109, -0.0001697965, -0.0006809522, -0.0014806704,
> -0.0024421544, -0.0033747331, -0.0040461515, -0.0042152551,
> -0.0036715016, -0.0022762546, +0.0000001108, +0.0030514489,
> +0.0066249269, +0.0103299287, +0.0136685095, +0.0160863582,
> +0.0170402654, +0.0160753010, +0.0129026934, +0.0074680989,
> -0.0000001474, -0.0089719770, -0.0186323454, -0.0279367174,
> -0.0357036972, -0.0407384004, -0.0419755869, -0.0386278205,
> -0.0303215365, -0.0172032909, +0.0000001003, +0.0199803422,
> +0.0409128426, +0.0605890599, +0.0766093147, +0.0866219429,
> +0.0885881187, +0.0810468217, +0.0633519160, +0.0358536263,
> +0.0000000036, -0.0416598689, -0.0855806294, -0.1274328627,
> -0.1624114535, -0.1856183011, -0.1924887443, -0.1792247135,
> -0.1431946229, -0.0832608184, -0.0000001053, +0.1042088213,
> +0.2252460052, +0.3574607651, +0.4940202096, +0.6273707005,
> +0.7497761209, +0.8538888137, +0.9333050389, +0.9830572208,
> +1.0000001471, +0.9830572208, +0.9333050389, +0.8538888137,
> +0.7497761209, +0.6273707005, +0.4940202096, +0.3574607651,
> +0.2252460052, +0.1042088213, -0.0000001053, -0.0832608184,
> -0.1431946229, -0.1792247135, -0.1924887443, -0.1856183011,
> -0.1624114535, -0.1274328627, -0.0855806294, -0.0416598689,
> +0.0000000036, +0.0358536263, +0.0633519160, +0.0810468217,
> +0.0885881187, +0.0866219429, +0.0766093147, +0.0605890599,
> +0.0409128426, +0.0199803422, +0.0000001003, -0.0172032909,
> -0.0303215365, -0.0386278205, -0.0419755869, -0.0407384004,
> -0.0357036972, -0.0279367174, -0.0186323454, -0.0089719770,
> -0.0000001474, +0.0074680989, +0.0129026934, +0.0160753010,
> +0.0170402654, +0.0160863582, +0.0136685095, +0.0103299287,
> +0.0066249269, +0.0030514489, +0.0000001108, -0.0022762546,
> -0.0036715016, -0.0042152551, -0.0040461515, -0.0033747331,
> -0.0024421544, -0.0014806704, -0.0006809522, -0.0001697965,
> -0.0000000109, -0.0001524277, -0.0005483595, -0.0010695625,
> -0.0015820462,
> };
>
>const filterData filter7(FIR, lowPass, 9.996883969e+00, 65, 0, filterTaps7, 0, "45dB stop, 0.05dB ripple, linear phase, delay 32 steps", 1000000, 50000, 60000);
>const uint32_t maxFilterCount(7);
># 27 "../src/wildfire.h" 2
># 1 "../src/camera.h" 1
># 20 "../src/camera.h"
>class image
>{
>public:
> image(const char *name);
> ~image();
> char *fileName;
>};
>
>
>
>
>class cameraControl
>{
>public:
> image getImage(std::string *time, const char *name = 0);
>};
>
>extern cameraControl camera;
># 28 "../src/wildfire.h" 2
># 1 "../src/iwfassert.h" 1
># 29 "../src/wildfire.h" 2
>
>
>
>extern const uint32_t revision;
>
>
>
>const uint32_t minIwccRevision = 450;
>
>typedef boost::circular_buffer<short> circBufferS;
>typedef boost::circular_buffer<double> circBufferD;
>
>
>
>typedef char tchar;
>
>
>
>
>
>
>
>namespace history
>{
> class targetHistory;
>}
>
>namespace iwf
>{
>
>
>
> extern const char * wildfireString;
> extern const char * wildfireVerString;
> extern const char * debuggingString;
> extern const char * readyString;
> extern const char * targetFoundString;
> extern const char * positionString;
> extern const char * sizeString;
> extern const char * certaintyString;
> extern const char * percentString;
> extern const char * degreesString;
> extern const char * finishedTestString;
> extern const char * commandReceivedString;
> extern const char * commandProcessedString;
> extern const char * unrecognisedCommandString;
> extern const char * noPointsSetString;
> extern const char * badPointsSetString;
> extern const char * noPositionString;
> extern const char * noPointDefinedString;
> extern const char * invalidParameterString;
> extern const char * invalidUpdateParametersString;
> extern const char * errorReplacingIWFstring;
> extern const char * errorWritingFirmwareString;
> extern const char * errorReadingFirmwareString;
> extern const char * errorReadingIWFstring;
> extern const char * saveStateErrorString;
> extern const char * loadStateErrorString;
> extern const char * badBoardNameString;
> extern const char * unableToLoadStateString;
> extern const char * errorString;
> extern const char * warningString;
> extern const char * defPasswordString;
> extern const char * gainString;
> extern const char * powerString;
> extern const char * arrayString;
> extern const char * initialDetectionMessage;
> extern const char * strongDetectionMessage;
> extern const char * targetDetectionMessage;
> extern const char * dataFileColumnHeaders;
> extern const char * positionString;
> extern const char * codeLengthString;
> extern const char * repeatsString;
> extern const char * origOversamplingString;
> extern const char * codeRateString;
> extern const char * isFilteredString;
> extern const char * oversamplingString;
> extern const char * isCorrelatedString;
> extern const char * isFFTString;
> extern const char * timeLabelString;
> extern const char * separatorString;
> extern const char * imageFolderName;
> extern const char * dataFolderName;
> extern const char * imageExtension;
> extern const char * dataExtension;
> extern const char * compressedExtension;
> extern const char * defPictureName;
> extern const char * cameraCaptureString;
> extern const char * cameraURL;
> extern const char * calDiffString;
> extern const char * needDumpfileString2;
> extern const char * needDumpfileString1;
> extern const char * badFirmwareRevString1;
> extern const char * badFirmwareRevString2;
> extern const char * unimplementedString;
> extern const char * readCalDataString;
> extern const char * readRefDataString;
> extern const char * readStateFileString;
> extern const char * performingCalibrationString;
> extern const char * noSuchTargetString;
> extern const char * noMatchingFilesString;
> extern const char * pingString;
> extern const char * newPasswordSetString;
> extern const char * oldPasswordIncorrectString;
> extern const char * badPasswordString;
> extern const char * iwccTemperatureString;
> extern const char * iwccDegreesCString;
> extern const char * IDfileName;
> extern const char * noIDstring;
> extern const char * calRefString;
> extern const char * calNullString;
>
>
>
>
>extern const char* kspace;
>extern const char* kscolon;
>extern const char* kcomma;
>extern const char* ktab;
>
>
>
> class wildfireStatus
> {
> public:
> wildfireStatus();
> void recalc();
> void reset();
> void addFilter(filterImplement);
> void buildFilters();
>
> std::string password;
> std::vector<filterImplement> filters;
> history::targetHistory *tHistory;
> std::string *systemID;
>
> double stepSize;
> double startPosition;
> double stopPosition;
> double maxAltitude;
> double minAltitude;
> double codeRate;
> double sampleRate;
> double detectionRatio;
> double alarmRatio;
> double horizSensorPosition;
> double vertSensorPosition;
>
> clock_t startTime;
> clock_t currentTime;
> clock_t lastCalTime;
>
> uint32_t codeLength;
> uint32_t startRepeats;
> uint32_t maxRepeats;
> uint32_t repeatMult;
> uint32_t origOversampleRate;
> uint32_t finalOversampleRate;
> uint32_t singleCodeSamples;
> uint32_t singleCodeFilteredSamples;
> uint32_t debugLevel;
> uint32_t testNumber;
>
> const double *code;
>
> tpower initialPowerLevel;
> rgain initialGain;
> rbw initialBandwidth;
>
> bool debug;
> bool autoGain;
> bool feedbackLow;
> bool noStore;
> bool processedCode;
> bool testMode;
> bool doFilter;
> bool foundCorrelation;
> bool foundFft;
> bool plotAll;
> bool demo;
> bool noFirmwareCheck;
>
> };
>
>
>
> const uint32_t defCodeLength1 = 64;
> const uint32_t defCodeLength2 = 640;
> const uint32_t defCodeLength3 = 1024;
> const uint32_t defCodeLength4 = 256;
> const uint32_t defOversampleRate1 = 50;
> const uint32_t defOversampleRate2 = 10;
> const uint32_t defOversampleRate3 = 8;
> const uint32_t defOversampleRate4 = 8;
> const double defCodeRate1 = 78.125;
> const double defCodeRate2 = 156.25;
> const double defCodeRate3 = 146.484375;
> const double defCodeRate4 = 585.9375;
> const uint32_t defRepeats = 128;
> const uint32_t defMaxRepeats = 8192;
> const uint32_t defRepeatMult = 4;
> const bool defDoFilter = false;
> const bool defDoDebugging = false;
> const bool defAllData = false;
> const uint32_t defDebugLevel = 2;
> const uint32_t defMaxScanTime = 60;
> const uint32_t defFilteringType = 2;
> const double defStartPos = 0;
> const double defStepSize = 2.0;
> const double defStopPos = 360 - defStepSize;
> const tpower defPowerLevel = 3000;
> const rgain defGain = g500;
> const rbw defBandwidth = bw2000;
>
>
>
> const double defCode1[]=
> {
> -1,-1,-1,-1, 1, 1,-1, 1, 1, 1, 1,-1, 1,-1,-1, 1,-1,-1,-1,-1,-1, 1,
> -1,-1, 1,-1, 1,-1, 1, 1, 1, 1,-1, 1,-1, 1, 1, 1,-1, 1,-1, 1, 1, 1,
> -1, 1, 1,-1,-1, 1, 1, 1,-1,-1,-1,-1, 1,-1,-1, 1, 1, 1,-1,-1
> };
>
> const double defCode2[]=
> {
> -1,-1,-1,-1,1,1,-1,1,-1,1,1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,-1,1,-1,1,1,1,-1,-1,-1,1,1,-1,-1,1,1,-1,1,-1,-1,-1,-1,-1,-1,1,1,1,1,1,1,
> -1,1,1,-1,1,-1,1,1,1,1,1,1,1,1,1,1,-1,1,-1,1,1,1,-1,1,-1,1,1,-1,-1,1,1,1,-1,-1,-1,1,1,-1,-1,1,-1,1,1,1,1,-1,-1,1,-1,1,-1,1,-1,1,1,
> -1,-1,1,1,1,-1,-1,1,-1,-1,-1,1,-1,-1,-1,1,-1,-1,1,1,-1,-1,1,1,1,1,-1,-1,1,1,1,-1,1,1,-1,1,-1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
> 1,-1,1,1,-1,-1,-1,1,-1,1,-1,-1,-1,-1,-1,-1,-1,-1,1,-1,1,1,-1,1,1,-1,-1,-1,-1,-1,1,-1,1,-1,1,-1,1,-1,-1,1,-1,-1,-1,1,-1,-1,1,1,1,1,
> 1,1,-1,1,-1,1,-1,-1,1,-1,1,-1,1,1,-1,1,-1,1,1,-1,1,1,-1,-1,1,-1,1,-1,1,1,1,-1,1,1,-1,-1,1,-1,-1,1,-1,-1,1,-1,-1,-1,-1,1,-1,-1,-1,-1,
> 1,-1,-1,-1,1,-1,1,-1,1,1,1,1,1,1,1,1,-1,-1,-1,1,-1,1,-1,-1,1,1,-1,-1,1,-1,1,1,1,1,-1,1,-1,-1,1,-1,1,-1,1,-1,-1,1,1,-1,1,-1,1,1,-1,1,
> -1,-1,-1,1,-1,1,-1,-1,1,-1,-1,1,-1,1,1,-1,-1,1,1,1,-1,-1,-1,-1,1,1,1,-1,1,-1,1,1,-1,-1,1,1,1,-1,1,-1,-1,1,-1,1,1,-1,1,1,1,-1,1,1,-1,
> 1,-1,1,1,-1,-1,-1,-1,-1,-1,1,-1,1,-1,1,-1,1,1,1,-1,-1,-1,1,1,1,-1,1,1,-1,1,1,-1,-1,-1,-1,1,1,1,1,-1,-1,-1,1,1,1,-1,-1,1,1,-1,1,1,1,
> 1,-1,-1,-1,-1,-1,1,-1,1,1,-1,1,-1,-1,1,-1,-1,-1,1,-1,1,-1,-1,1,1,-1,-1,1,-1,-1,-1,-1,1,-1,-1,-1,-1,1,-1,1,1,-1,1,-1,1,1,1,1,1,-1,-1,
> 1,-1,1,-1,-1,-1,-1,-1,-1,1,-1,1,1,1,1,1,1,-1,-1,1,-1,-1,1,-1,1,1,-1,1,-1,-1,1,1,1,1,1,1,-1,1,1,1,-1,-1,1,1,1,-1,1,1,1,-1,-1,-1,-1,
> -1,1,1,1,-1,-1,1,-1,1,1,-1,1,1,-1,1,1,-1,1,-1,1,-1,-1,-1,1,1,-1,-1,-1,1,1,-1,-1,-1,1,-1,-1,1,1,-1,-1,-1,-1,1,1,-1,-1,-1,1,-1,-1,1,1,
> -1,1,-1,-1,-1,-1,1,-1,1,1,-1,1,-1,1,1,1,1,1,-1,-1,-1,1,1,1,1,1,-1,-1,1,-1,1,1,1,1,-1,-1,-1,1,1,1,1,1,-1,-1,-1,1,-1,1,1,-1,-1,-1,1,
> -1,-1,-1,1,1,1,1,-1,1,-1,-1
> };
>
> const double defCode3[]=
> {
> -1,1,1,-1,-1,1,-1,1,1,1,-1,-1,-1,1,1,-1,-1,1,-1,1,1,1,1,-1,1,1,1,-1,1,-1,1,1,-1,-1,1,-1,-1,-1,1,-1,1,-1,1,1,-1,-1,-1,-1,-1,-1,-1,-1,1,
> 1,-1,1,-1,1,-1,1,-1,1,1,-1,1,-1,-1,-1,1,1,-1,1,-1,-1,-1,-1,1,-1,1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,1,1,1,1,1,-1,-1,1,1,1,1,-1,-1,1,-1,1,-1,
> -1,-1,1,-1,1,1,-1,1,1,1,1,-1,-1,1,-1,-1,1,-1,1,1,1,-1,-1,1,1,1,1,1,1,1,1,-1,-1,-1,1,1,1,-1,-1,-1,1,-1,1,-1,1,-1,1,1,1,-1,1,1,1,-1,-1,
> -1,1,-1,1,1,-1,-1,1,-1,1,-1,1,-1,-1,1,1,1,1,-1,1,-1,1,-1,1,1,1,-1,-1,1,-1,-1,-1,1,1,1,-1,1,1,-1,-1,1,-1,1,-1,-1,-1,1,-1,-1,-1,1,1,1,-1,
> 1,-1,1,-1,1,-1,1,1,-1,1,1,1,1,1,-1,-1,-1,-1,1,1,1,1,1,1,1,-1,1,1,-1,-1,-1,-1,1,-1,-1,-1,1,1,-1,1,-1,1,-1,1,-1,-1,1,-1,-1,-1,1,1,-1,-1,
> 1,-1,1,-1,1,1,-1,-1,-1,-1,1,1,-1,-1,1,1,-1,-1,-1,1,-1,-1,1,1,1,1,-1,-1,-1,-1,1,-1,-1,1,1,-1,1,-1,-1,-1,1,1,1,1,1,-1,1,1,-1,-1,1,1,1,1,
> -1,-1,1,-1,1,-1,1,1,1,-1,-1,1,1,-1,1,1,1,1,1,-1,1,-1,-1,-1,1,-1,-1,1,-1,-1,1,1,-1,1,-1,-1,1,-1,-1,1,-1,-1,1,1,-1,1,-1,1,-1,1,-1,-1,-1,
> -1,1,1,-1,1,1,1,1,1,-1,1,1,-1,1,1,1,-1,-1,1,-1,-1,-1,1,1,-1,1,1,1,-1,-1,-1,1,-1,1,-1,1,1,-1,-1,-1,-1,1,-1,-1,1,-1,1,-1,-1,1,-1,-1,-1,-1,
> -1,-1,1,1,1,1,1,-1,1,-1,1,1,1,-1,-1,1,1,-1,-1,1,1,1,1,-1,1,-1,-1,-1,-1,1,-1,1,-1,1,1,1,1,1,1,1,1,-1,-1,-1,-1,1,1,-1,1,-1,-1,-1,-1,1,1,
> -1,-1,1,-1,1,1,-1,1,1,-1,-1,1,-1,1,1,-1,1,-1,-1,-1,-1,1,1,-1,1,-1,-1,1,-1,1,1,1,1,1,1,-1,-1,1,1,1,1,-1,-1,-1,-1,-1,1,-1,1,1,-1,-1,1,1,
> -1,-1,-1,-1,-1,1,1,1,-1,-1,-1,1,1,-1,1,-1,-1,-1,1,1,-1,1,-1,-1,1,1,1,-1,1,-1,-1,1,1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,1,1,1,-1,1,-1,-1,1,1,1,
> -1,-1,1,-1,1,-1,-1,1,1,1,-1,1,1,-1,1,-1,1,1,1,1,-1,1,1,-1,-1,-1,-1,-1,1,1,-1,-1,-1,1,1,1,1,-1,-1,1,-1,-1,-1,-1,1,-1,1,-1,-1,1,1,1,-1,-1,
> -1,-1,1,-1,1,1,1,-1,1,1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,-1,1,-1,-1,-1,1,-1,-1,1,-1,-1,1,1,1,-1,1,-1,1,1,1,-1,1,-1,1,-1,1,1,-1,1,-1,1,1,1,-1,
> 1,1,1,1,-1,1,-1,1,-1,1,-1,1,-1,1,1,1,-1,-1,-1,1,-1,-1,-1,1,1,-1,-1,-1,-1,-1,1,1,-1,1,1,1,1,-1,-1,1,-1,1,-1,1,1,-1,1,-1,1,-1,1,-1,1,-1,
> -1,-1,1,-1,-1,-1,-1,-1,-1,1,1,-1,-1,-1,-1,1,-1,-1,1,1,-1,-1,1,1,-1,1,1,1,-1,1,1,1,-1,-1,-1,1,1,-1,1,-1,-1,1,-1,1,1,-1,-1,-1,-1,1,-1,-1,
> -1,1,1,1,1,-1,-1,-1,1,-1,1,-1,1,-1,1,1,1,-1,1,1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,-1,1,1,1,-1,1,-1,1,-1,1,1,-1,-1,-1,-1,-1,1,-1,1,1,-1,-1,1,1,
> 1,-1,1,1,-1,1,1,-1,1,1,1,-1,-1,1,1,1,-1,-1,-1,-1,1,-1,-1,1,1,-1,-1,1,1,-1,-1,1,-1,-1,1,1,-1,-1,1,-1,-1,-1,1,-1,1,1,-1,1,-1,1,-1,-1,1,-1,
> 1,-1,-1,-1,1,-1,1,1,-1,-1,-1,1,1,-1,1,1,-1,-1,-1,1,-1,1,1,-1,-1,-1,-1,1,-1,-1,-1,1,-1,-1,-1,-1,-1,-1,-1,1,-1,1,1,-1,-1,1,1,1,1,-1,1,-1,
> -1,1,-1,1,1,1,1,-1,-1,1,1,-1,-1,1,1,-1,1,-1,-1,-1,1,-1,-1,1,1,-1,-1,-1,1,-1,1,-1,1,1,-1,-1,-1,-1,1,1,1,1,1,-1,1,-1,1,-1,1,1,-1,-1,1,1
> };
>
> const double defCode4[] =
> {
> 1,-1,-1,1,-1,-1,1,-1,1,-1,-1,-1,-1,1,-1,-1,1,1,1,1,1,1,-1,-1,-1,-1,1,1,-1,-1,-1,1,-1,1,-1,-1,1,1,-1,1,1,1,-1,1,-1,-1,1,-1,1,1,1,-1,1,
> -1,-1,1,-1,1,-1,-1,1,-1,1,-1,-1,-1,1,-1,-1,1,-1,1,-1,1,1,-1,-1,1,1,-1,-1,1,-1,1,-1,-1,1,1,-1,1,1,1,1,-1,-1,1,1,-1,-1,1,-1,-1,-1,1,-1,
> -1,1,-1,1,1,1,1,-1,-1,1,-1,-1,-1,1,-1,1,1,1,1,1,-1,1,-1,1,-1,1,1,-1,-1,1,1,1,-1,1,-1,-1,-1,1,-1,-1,1,-1,1,-1,-1,1,-1,1,1,1,-1,-1,1,-1,
> 1,-1,-1,1,1,-1,-1,-1,1,1,-1,-1,-1,1,1,1,-1,1,-1,1,-1,1,-1,-1,1,1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,1,-1,1,1,-1,-1,-1,1,-1,1,-1,1,-1,1,-1,1,
> -1,1,1,1,1,-1,1,1,-1,-1,1,1,-1,1,-1,1,-1,1,1,1,1,-1,1,1,1,1,-1,-1,1,1,1,1,-1,-1,-1,1,1,1,1,1,-1,-1,1,-1,-1
> };
>
>
>
>
> const double saturationLimit = 6.0;
> const double absoluteSaturationLimit = 6.0;
>
>
>
> const double defDetectionRatio = 2;
> const double defAlarmRatio = 10;
>
>
>
> const uint32_t maxDecimate = 10;
> const uint32_t maxOversampleRate = 250;
> const uint32_t minRepeats = 1;
> const uint32_t maxRepeats = 32768;
> const uint32_t minPower = 0;
> const uint32_t maxPower = 4500;
> const double minRatio = 0;
> const double maxRatio = 120;
> const double maxStepSize = 30;
> const double minStepSize = 0.1;
> const uint32_t maxDebugLevel = 4;
>
>
>
>
> inline void wait(double seconds)
> {
> struct timespec timeOut,remains;
>
> timeOut.tv_sec = time_t(floor(seconds));
> timeOut.tv_nsec = time_t((seconds - floor(seconds)) * 1e9);
>
> if (nanosleep(&timeOut, &remains) == -1)
> {
> double newwait = double(remains.tv_sec) + double(remains.tv_nsec) * 1e-9;
> wait(newwait);
> };
> }
>}
>
>using namespace iwf;
>
>extern bool stride;
>extern double * tcode;
>
>
>
>std::ostream & operator << (std::ostream &out, iwf::wildfireStatus &stat);
>
>
>
>
>class measurementSettings;
>int doTests(iwf::wildfireStatus &stats, iWCCclass &iWCC, measurementSettings &settings, cameraControl &camera);
>
>
>
>std::string *getTimeStamp();
># 15 "../src/wildfire.cpp" 2
># 1 "../src/measure.h" 1
># 17 "../src/measure.h"
># 1 "../src/position.h" 1
># 20 "../src/position.h"
># 1 "/usr/include/c++/4.8.2/list" 1 3
># 58 "/usr/include/c++/4.8.2/list" 3
> 
># 59 "/usr/include/c++/4.8.2/list" 3
>
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/stl_list.h" 1 3
># 64 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
> namespace __detail
> {
> 
># 77 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> struct _List_node_base
> {
> _List_node_base* _M_next;
> _List_node_base* _M_prev;
>
> static void
> swap(_List_node_base& __x, _List_node_base& __y) noexcept;
>
> void
> _M_transfer(_List_node_base* const __first,
> _List_node_base* const __last) noexcept;
>
> void
> _M_reverse() noexcept;
>
> void
> _M_hook(_List_node_base* const __position) noexcept;
>
> void
> _M_unhook() noexcept;
> };
>
> 
> }
>
>
>
>
> template<typename _Tp>
> struct _List_node : public __detail::_List_node_base
> {
>
> _Tp _M_data;
>
>
> template<typename... _Args>
> _List_node(_Args&&... __args)
> : __detail::_List_node_base(), _M_data(std::forward<_Args>(__args)...)
> { }
>
> };
>
>
>
>
>
>
> template<typename _Tp>
> struct _List_iterator
> {
> typedef _List_iterator<_Tp> _Self;
> typedef _List_node<_Tp> _Node;
>
> typedef ptrdiff_t difference_type;
> typedef std::bidirectional_iterator_tag iterator_category;
> typedef _Tp value_type;
> typedef _Tp* pointer;
> typedef _Tp& reference;
>
> _List_iterator()
> : _M_node() { }
>
> explicit
> _List_iterator(__detail::_List_node_base* __x)
> : _M_node(__x) { }
>
>
> reference
> operator*() const
> { return static_cast<_Node*>(_M_node)->_M_data; }
>
> pointer
> operator->() const
> { return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); }
>
> _Self&
> operator++()
> {
> _M_node = _M_node->_M_next;
> return *this;
> }
>
> _Self
> operator++(int)
> {
> _Self __tmp = *this;
> _M_node = _M_node->_M_next;
> return __tmp;
> }
>
> _Self&
> operator--()
> {
> _M_node = _M_node->_M_prev;
> return *this;
> }
>
> _Self
> operator--(int)
> {
> _Self __tmp = *this;
> _M_node = _M_node->_M_prev;
> return __tmp;
> }
>
> bool
> operator==(const _Self& __x) const
> { return _M_node == __x._M_node; }
>
> bool
> operator!=(const _Self& __x) const
> { return _M_node != __x._M_node; }
>
>
> __detail::_List_node_base* _M_node;
> };
>
>
>
>
>
>
> template<typename _Tp>
> struct _List_const_iterator
> {
> typedef _List_const_iterator<_Tp> _Self;
> typedef const _List_node<_Tp> _Node;
> typedef _List_iterator<_Tp> iterator;
>
> typedef ptrdiff_t difference_type;
> typedef std::bidirectional_iterator_tag iterator_category;
> typedef _Tp value_type;
> typedef const _Tp* pointer;
> typedef const _Tp& reference;
>
> _List_const_iterator()
> : _M_node() { }
>
> explicit
> _List_const_iterator(const __detail::_List_node_base* __x)
> : _M_node(__x) { }
>
> _List_const_iterator(const iterator& __x)
> : _M_node(__x._M_node) { }
>
>
>
> reference
> operator*() const
> { return static_cast<_Node*>(_M_node)->_M_data; }
>
> pointer
> operator->() const
> { return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); }
>
> _Self&
> operator++()
> {
> _M_node = _M_node->_M_next;
> return *this;
> }
>
> _Self
> operator++(int)
> {
> _Self __tmp = *this;
> _M_node = _M_node->_M_next;
> return __tmp;
> }
>
> _Self&
> operator--()
> {
> _M_node = _M_node->_M_prev;
> return *this;
> }
>
> _Self
> operator--(int)
> {
> _Self __tmp = *this;
> _M_node = _M_node->_M_prev;
> return __tmp;
> }
>
> bool
> operator==(const _Self& __x) const
> { return _M_node == __x._M_node; }
>
> bool
> operator!=(const _Self& __x) const
> { return _M_node != __x._M_node; }
>
>
> const __detail::_List_node_base* _M_node;
> };
>
> template<typename _Val>
> inline bool
> operator==(const _List_iterator<_Val>& __x,
> const _List_const_iterator<_Val>& __y)
> { return __x._M_node == __y._M_node; }
>
> template<typename _Val>
> inline bool
> operator!=(const _List_iterator<_Val>& __x,
> const _List_const_iterator<_Val>& __y)
> { return __x._M_node != __y._M_node; }
>
>
>
> template<typename _Tp, typename _Alloc>
> class _List_base
> {
> protected:
># 305 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> typedef typename _Alloc::template rebind<_List_node<_Tp> >::other
> _Node_alloc_type;
>
> typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
>
> struct _List_impl
> : public _Node_alloc_type
> {
> __detail::_List_node_base _M_node;
>
> _List_impl()
> : _Node_alloc_type(), _M_node()
> { }
>
> _List_impl(const _Node_alloc_type& __a)
> : _Node_alloc_type(__a), _M_node()
> { }
>
>
> _List_impl(_Node_alloc_type&& __a)
> : _Node_alloc_type(std::move(__a)), _M_node()
> { }
>
> };
>
> _List_impl _M_impl;
>
> _List_node<_Tp>*
> _M_get_node()
> { return _M_impl._Node_alloc_type::allocate(1); }
>
> void
> _M_put_node(_List_node<_Tp>* __p)
> { _M_impl._Node_alloc_type::deallocate(__p, 1); }
>
> public:
> typedef _Alloc allocator_type;
>
> _Node_alloc_type&
> _M_get_Node_allocator() noexcept
> { return *static_cast<_Node_alloc_type*>(&_M_impl); }
>
> const _Node_alloc_type&
> _M_get_Node_allocator() const noexcept
> { return *static_cast<const _Node_alloc_type*>(&_M_impl); }
>
> _Tp_alloc_type
> _M_get_Tp_allocator() const noexcept
> { return _Tp_alloc_type(_M_get_Node_allocator()); }
>
> allocator_type
> get_allocator() const noexcept
> { return allocator_type(_M_get_Node_allocator()); }
>
> _List_base()
> : _M_impl()
> { _M_init(); }
>
> _List_base(const _Node_alloc_type& __a)
> : _M_impl(__a)
> { _M_init(); }
>
>
> _List_base(_List_base&& __x)
> : _M_impl(std::move(__x._M_get_Node_allocator()))
> {
> _M_init();
> __detail::_List_node_base::swap(_M_impl._M_node, __x._M_impl._M_node);
> }
>
>
>
> ~_List_base() noexcept
> { _M_clear(); }
>
> void
> _M_clear();
>
> void
> _M_init()
> {
> this->_M_impl._M_node._M_next = &this->_M_impl._M_node;
> this->_M_impl._M_node._M_prev = &this->_M_impl._M_node;
> }
> };
># 437 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
> class list : protected _List_base<_Tp, _Alloc>
> {
>
> typedef typename _Alloc::value_type _Alloc_value_type;
> 
> 
>
> typedef _List_base<_Tp, _Alloc> _Base;
> typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
> typedef typename _Base::_Node_alloc_type _Node_alloc_type;
>
> public:
> typedef _Tp value_type;
> typedef typename _Tp_alloc_type::pointer pointer;
> typedef typename _Tp_alloc_type::const_pointer const_pointer;
> typedef typename _Tp_alloc_type::reference reference;
> typedef typename _Tp_alloc_type::const_reference const_reference;
> typedef _List_iterator<_Tp> iterator;
> typedef _List_const_iterator<_Tp> const_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Alloc allocator_type;
>
> protected:
>
>
> typedef _List_node<_Tp> _Node;
>
> using _Base::_M_impl;
> using _Base::_M_put_node;
> using _Base::_M_get_node;
> using _Base::_M_get_Tp_allocator;
> using _Base::_M_get_Node_allocator;
># 498 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> template<typename... _Args>
> _Node*
> _M_create_node(_Args&&... __args)
> {
> _Node* __p = this->_M_get_node();
> try
> {
> _M_get_Node_allocator().construct(__p,
> std::forward<_Args>(__args)...);
> }
> catch(...)
> {
> _M_put_node(__p);
> throw;
> }
> return __p;
> }
>
>
> public:
>
>
>
>
>
> list()
> : _Base() { }
>
>
>
>
>
> explicit
> list(const allocator_type& __a)
> : _Base(_Node_alloc_type(__a)) { }
># 542 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> explicit
> list(size_type __n)
> : _Base()
> { _M_default_initialize(__n); }
># 555 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> list(size_type __n, const value_type& __value,
> const allocator_type& __a = allocator_type())
> : _Base(_Node_alloc_type(__a))
> { _M_fill_initialize(__n, __value); }
># 582 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> list(const list& __x)
> : _Base(__x._M_get_Node_allocator())
> { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
># 594 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> list(list&& __x) noexcept
> : _Base(std::move(__x)) { }
># 605 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> list(initializer_list<value_type> __l,
> const allocator_type& __a = allocator_type())
> : _Base(_Node_alloc_type(__a))
> { _M_initialize_dispatch(__l.begin(), __l.end(), __false_type()); }
># 622 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> list(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Base(_Node_alloc_type(__a))
> { _M_initialize_dispatch(__first, __last, __false_type()); }
># 655 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> list&
> operator=(const list& __x);
># 666 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> list&
> operator=(list&& __x)
> {
>
>
> this->clear();
> this->swap(__x);
> return *this;
> }
># 683 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> list&
> operator=(initializer_list<value_type> __l)
> {
> this->assign(__l.begin(), __l.end());
> return *this;
> }
># 701 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
> assign(size_type __n, const value_type& __val)
> { _M_fill_assign(__n, __val); }
># 718 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> void
> assign(_InputIterator __first, _InputIterator __last)
> { _M_assign_dispatch(__first, __last, __false_type()); }
># 742 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
> assign(initializer_list<value_type> __l)
> { this->assign(__l.begin(), __l.end()); }
>
>
>
> allocator_type
> get_allocator() const noexcept
> { return _Base::get_allocator(); }
>
>
>
>
>
>
> iterator
> begin() noexcept
> { return iterator(this->_M_impl._M_node._M_next); }
>
>
>
>
>
>
> const_iterator
> begin() const noexcept
> { return const_iterator(this->_M_impl._M_node._M_next); }
>
>
>
>
>
>
> iterator
> end() noexcept
> { return iterator(&this->_M_impl._M_node); }
>
>
>
>
>
>
> const_iterator
> end() const noexcept
> { return const_iterator(&this->_M_impl._M_node); }
>
>
>
>
>
>
> reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(end()); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
>
>
>
>
>
> reverse_iterator
> rend() noexcept
> { return reverse_iterator(begin()); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
>
>
>
>
>
> const_iterator
> cbegin() const noexcept
> { return const_iterator(this->_M_impl._M_node._M_next); }
>
>
>
>
>
>
> const_iterator
> cend() const noexcept
> { return const_iterator(&this->_M_impl._M_node); }
>
>
>
>
>
>
> const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
>
>
>
>
>
> const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
>
>
>
>
>
> bool
> empty() const noexcept
> { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; }
>
>
> size_type
> size() const noexcept
> { return std::distance(begin(), end()); }
>
>
> size_type
> max_size() const noexcept
> { return _M_get_Node_allocator().max_size(); }
># 891 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
> resize(size_type __new_size);
># 904 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
> resize(size_type __new_size, const value_type& __x);
># 926 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> reference
> front()
> { return *begin(); }
>
>
>
>
>
> const_reference
> front() const
> { return *begin(); }
>
>
>
>
>
> reference
> back()
> {
> iterator __tmp = end();
> --__tmp;
> return *__tmp;
> }
>
>
>
>
>
> const_reference
> back() const
> {
> const_iterator __tmp = end();
> --__tmp;
> return *__tmp;
> }
># 973 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
> push_front(const value_type& __x)
> { this->_M_insert(begin(), __x); }
>
>
> void
> push_front(value_type&& __x)
> { this->_M_insert(begin(), std::move(__x)); }
>
> template<typename... _Args>
> void
> emplace_front(_Args&&... __args)
> { this->_M_insert(begin(), std::forward<_Args>(__args)...); }
># 1000 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
> pop_front()
> { this->_M_erase(begin()); }
># 1014 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
> push_back(const value_type& __x)
> { this->_M_insert(end(), __x); }
>
>
> void
> push_back(value_type&& __x)
> { this->_M_insert(end(), std::move(__x)); }
>
> template<typename... _Args>
> void
> emplace_back(_Args&&... __args)
> { this->_M_insert(end(), std::forward<_Args>(__args)...); }
># 1040 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
> pop_back()
> { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }
># 1057 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> template<typename... _Args>
> iterator
> emplace(iterator __position, _Args&&... __args);
># 1073 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> iterator
> insert(iterator __position, const value_type& __x);
># 1088 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> iterator
> insert(iterator __position, value_type&& __x)
> { return emplace(__position, std::move(__x)); }
># 1105 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
> insert(iterator __p, initializer_list<value_type> __l)
> { this->insert(__p, __l.begin(), __l.end()); }
># 1122 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
> insert(iterator __position, size_type __n, const value_type& __x)
> {
> list __tmp(__n, __x, get_allocator());
> splice(__position, __tmp);
> }
># 1143 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
>
>
>
> void
> insert(iterator __position, _InputIterator __first,
> _InputIterator __last)
> {
> list __tmp(__first, __last, get_allocator());
> splice(__position, __tmp);
> }
># 1171 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> iterator
> erase(iterator __position);
># 1192 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> iterator
> erase(iterator __first, iterator __last)
> {
> while (__first != __last)
> __first = erase(__first);
> return __last;
> }
># 1209 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
> swap(list& __x)
> {
> __detail::_List_node_base::swap(this->_M_impl._M_node,
> __x._M_impl._M_node);
>
>
>
> std::__alloc_swap<typename _Base::_Node_alloc_type>::
> _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator());
> }
>
>
>
>
>
>
>
> void
> clear() noexcept
> {
> _Base::_M_clear();
> _Base::_M_init();
> }
># 1246 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
>
> splice(iterator __position, list&& __x)
>
>
>
> {
> if (!__x.empty())
> {
> _M_check_equal_allocators(__x);
>
> this->_M_transfer(__position, __x.begin(), __x.end());
> }
> }
>
>
> void
> splice(iterator __position, list& __x)
> { splice(__position, std::move(__x)); }
># 1276 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
>
> splice(iterator __position, list&& __x, iterator __i)
>
>
>
> {
> iterator __j = __i;
> ++__j;
> if (__position == __i || __position == __j)
> return;
>
> if (this != &__x)
> _M_check_equal_allocators(__x);
>
> this->_M_transfer(__position, __i, __j);
> }
>
>
> void
> splice(iterator __position, list& __x, iterator __i)
> { splice(__position, std::move(__x), __i); }
># 1312 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
>
> splice(iterator __position, list&& __x, iterator __first,
> iterator __last)
>
>
>
>
> {
> if (__first != __last)
> {
> if (this != &__x)
> _M_check_equal_allocators(__x);
>
> this->_M_transfer(__position, __first, __last);
> }
> }
>
>
> void
> splice(iterator __position, list& __x, iterator __first, iterator __last)
> { splice(__position, std::move(__x), __first, __last); }
># 1347 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
> remove(const _Tp& __value);
># 1361 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> template<typename _Predicate>
> void
> remove_if(_Predicate);
># 1375 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
> unique();
># 1390 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> template<typename _BinaryPredicate>
> void
> unique(_BinaryPredicate);
># 1404 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
> merge(list&& __x);
>
> void
> merge(list& __x)
> { merge(std::move(__x)); }
># 1429 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> template<typename _StrictWeakOrdering>
> void
> merge(list&& __x, _StrictWeakOrdering __comp);
>
> template<typename _StrictWeakOrdering>
> void
> merge(list& __x, _StrictWeakOrdering __comp)
> { merge(std::move(__x), __comp); }
># 1448 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> void
> reverse() noexcept
> { this->_M_impl._M_node._M_reverse(); }
>
>
>
>
>
>
>
> void
> sort();
>
>
>
>
>
>
>
> template<typename _StrictWeakOrdering>
> void
> sort(_StrictWeakOrdering);
>
> protected:
>
>
>
>
>
>
> template<typename _Integer>
> void
> _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
> { _M_fill_initialize(static_cast<size_type>(__n), __x); }
>
>
> template<typename _InputIterator>
> void
> _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> for (; __first != __last; ++__first)
>
> emplace_back(*__first);
>
>
>
> }
>
>
>
> void
> _M_fill_initialize(size_type __n, const value_type& __x)
> {
> for (; __n; --__n)
> push_back(__x);
> }
>
>
>
> void
> _M_default_initialize(size_type __n)
> {
> for (; __n; --__n)
> emplace_back();
> }
>
>
> void
> _M_default_append(size_type __n);
># 1526 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> template<typename _Integer>
> void
> _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> { _M_fill_assign(__n, __val); }
>
>
> template<typename _InputIterator>
> void
> _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type);
>
>
>
> void
> _M_fill_assign(size_type __n, const value_type& __val);
>
>
>
> void
> _M_transfer(iterator __position, iterator __first, iterator __last)
> { __position._M_node->_M_transfer(__first._M_node, __last._M_node); }
># 1557 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> template<typename... _Args>
> void
> _M_insert(iterator __position, _Args&&... __args)
> {
> _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
> __tmp->_M_hook(__position._M_node);
> }
>
>
>
> void
> _M_erase(iterator __position)
> {
> __position._M_node->_M_unhook();
> _Node* __n = static_cast<_Node*>(__position._M_node);
>
> _M_get_Node_allocator().destroy(__n);
>
>
>
> _M_put_node(__n);
> }
>
>
> void
> _M_check_equal_allocators(list& __x)
> {
> if (std::__alloc_neq<typename _Base::_Node_alloc_type>::
> _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()))
> __throw_runtime_error(("list::_M_check_equal_allocators"));
> }
> };
># 1600 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> {
> typedef typename list<_Tp, _Alloc>::const_iterator const_iterator;
> const_iterator __end1 = __x.end();
> const_iterator __end2 = __y.end();
>
> const_iterator __i1 = __x.begin();
> const_iterator __i2 = __y.begin();
> while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2)
> {
> ++__i1;
> ++__i2;
> }
> return __i1 == __end1 && __i2 == __end2;
> }
># 1629 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> { return std::lexicographical_compare(__x.begin(), __x.end(),
> __y.begin(), __y.end()); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> { return __y < __x; }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline void
> swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
> { __x.swap(__y); }
>
>
>}
># 64 "/usr/include/c++/4.8.2/list" 2 3
># 1 "/usr/include/c++/4.8.2/bits/list.tcc" 1 3
># 59 "/usr/include/c++/4.8.2/bits/list.tcc" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Tp, typename _Alloc>
> void
> _List_base<_Tp, _Alloc>::
> _M_clear()
> {
> typedef _List_node<_Tp> _Node;
> _Node* __cur = static_cast<_Node*>(_M_impl._M_node._M_next);
> while (__cur != &_M_impl._M_node)
> {
> _Node* __tmp = __cur;
> __cur = static_cast<_Node*>(__cur->_M_next);
>
> _M_get_Node_allocator().destroy(__tmp);
>
>
>
> _M_put_node(__tmp);
> }
> }
>
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
> typename list<_Tp, _Alloc>::iterator
> list<_Tp, _Alloc>::
> emplace(iterator __position, _Args&&... __args)
> {
> _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
> __tmp->_M_hook(__position._M_node);
> return iterator(__tmp);
> }
>
>
> template<typename _Tp, typename _Alloc>
> typename list<_Tp, _Alloc>::iterator
> list<_Tp, _Alloc>::
> insert(iterator __position, const value_type& __x)
> {
> _Node* __tmp = _M_create_node(__x);
> __tmp->_M_hook(__position._M_node);
> return iterator(__tmp);
> }
>
> template<typename _Tp, typename _Alloc>
> typename list<_Tp, _Alloc>::iterator
> list<_Tp, _Alloc>::
> erase(iterator __position)
> {
> iterator __ret = iterator(__position._M_node->_M_next);
> _M_erase(__position);
> return __ret;
> }
>
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> _M_default_append(size_type __n)
> {
> size_type __i = 0;
> try
> {
> for (; __i < __n; ++__i)
> emplace_back();
> }
> catch(...)
> {
> for (; __i; --__i)
> pop_back();
> throw;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> resize(size_type __new_size)
> {
> iterator __i = begin();
> size_type __len = 0;
> for (; __i != end() && __len < __new_size; ++__i, ++__len)
> ;
> if (__len == __new_size)
> erase(__i, end());
> else
> _M_default_append(__new_size - __len);
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> resize(size_type __new_size, const value_type& __x)
> {
> iterator __i = begin();
> size_type __len = 0;
> for (; __i != end() && __len < __new_size; ++__i, ++__len)
> ;
> if (__len == __new_size)
> erase(__i, end());
> else
> insert(end(), __new_size - __len, __x);
> }
># 182 "/usr/include/c++/4.8.2/bits/list.tcc" 3
> template<typename _Tp, typename _Alloc>
> list<_Tp, _Alloc>&
> list<_Tp, _Alloc>::
> operator=(const list& __x)
> {
> if (this != &__x)
> {
> iterator __first1 = begin();
> iterator __last1 = end();
> const_iterator __first2 = __x.begin();
> const_iterator __last2 = __x.end();
> for (; __first1 != __last1 && __first2 != __last2;
> ++__first1, ++__first2)
> *__first1 = *__first2;
> if (__first2 == __last2)
> erase(__first1, __last1);
> else
> insert(__last1, __first2, __last2);
> }
> return *this;
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> _M_fill_assign(size_type __n, const value_type& __val)
> {
> iterator __i = begin();
> for (; __i != end() && __n > 0; ++__i, --__n)
> *__i = __val;
> if (__n > 0)
> insert(end(), __n, __val);
> else
> erase(__i, end());
> }
>
> template<typename _Tp, typename _Alloc>
> template <typename _InputIterator>
> void
> list<_Tp, _Alloc>::
> _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2,
> __false_type)
> {
> iterator __first1 = begin();
> iterator __last1 = end();
> for (; __first1 != __last1 && __first2 != __last2;
> ++__first1, ++__first2)
> *__first1 = *__first2;
> if (__first2 == __last2)
> erase(__first1, __last1);
> else
> insert(__last1, __first2, __last2);
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> remove(const value_type& __value)
> {
> iterator __first = begin();
> iterator __last = end();
> iterator __extra = __last;
> while (__first != __last)
> {
> iterator __next = __first;
> ++__next;
> if (*__first == __value)
> {
>
>
>
> if (std::__addressof(*__first) != std::__addressof(__value))
> _M_erase(__first);
> else
> __extra = __first;
> }
> __first = __next;
> }
> if (__extra != __last)
> _M_erase(__extra);
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> unique()
> {
> iterator __first = begin();
> iterator __last = end();
> if (__first == __last)
> return;
> iterator __next = __first;
> while (++__next != __last)
> {
> if (*__first == *__next)
> _M_erase(__next);
> else
> __first = __next;
> __next = __first;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
>
> merge(list&& __x)
>
>
>
> {
>
>
> if (this != &__x)
> {
> _M_check_equal_allocators(__x);
>
> iterator __first1 = begin();
> iterator __last1 = end();
> iterator __first2 = __x.begin();
> iterator __last2 = __x.end();
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first2 < *__first1)
> {
> iterator __next = __first2;
> _M_transfer(__first1, __first2, ++__next);
> __first2 = __next;
> }
> else
> ++__first1;
> if (__first2 != __last2)
> _M_transfer(__last1, __first2, __last2);
> }
> }
>
> template<typename _Tp, typename _Alloc>
> template <typename _StrictWeakOrdering>
> void
> list<_Tp, _Alloc>::
>
> merge(list&& __x, _StrictWeakOrdering __comp)
>
>
>
> {
>
>
> if (this != &__x)
> {
> _M_check_equal_allocators(__x);
>
> iterator __first1 = begin();
> iterator __last1 = end();
> iterator __first2 = __x.begin();
> iterator __last2 = __x.end();
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first2, *__first1))
> {
> iterator __next = __first2;
> _M_transfer(__first1, __first2, ++__next);
> __first2 = __next;
> }
> else
> ++__first1;
> if (__first2 != __last2)
> _M_transfer(__last1, __first2, __last2);
> }
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> sort()
> {
>
> if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
> && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
> {
> list __carry;
> list __tmp[64];
> list * __fill = &__tmp[0];
> list * __counter;
>
> do
> {
> __carry.splice(__carry.begin(), *this, begin());
>
> for(__counter = &__tmp[0];
> __counter != __fill && !__counter->empty();
> ++__counter)
> {
> __counter->merge(__carry);
> __carry.swap(*__counter);
> }
> __carry.swap(*__counter);
> if (__counter == __fill)
> ++__fill;
> }
> while ( !empty() );
>
> for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
> __counter->merge(*(__counter - 1));
> swap( *(__fill - 1) );
> }
> }
>
> template<typename _Tp, typename _Alloc>
> template <typename _Predicate>
> void
> list<_Tp, _Alloc>::
> remove_if(_Predicate __pred)
> {
> iterator __first = begin();
> iterator __last = end();
> while (__first != __last)
> {
> iterator __next = __first;
> ++__next;
> if (__pred(*__first))
> _M_erase(__first);
> __first = __next;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> template <typename _BinaryPredicate>
> void
> list<_Tp, _Alloc>::
> unique(_BinaryPredicate __binary_pred)
> {
> iterator __first = begin();
> iterator __last = end();
> if (__first == __last)
> return;
> iterator __next = __first;
> while (++__next != __last)
> {
> if (__binary_pred(*__first, *__next))
> _M_erase(__next);
> else
> __first = __next;
> __next = __first;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> template <typename _StrictWeakOrdering>
> void
> list<_Tp, _Alloc>::
> sort(_StrictWeakOrdering __comp)
> {
>
> if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
> && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
> {
> list __carry;
> list __tmp[64];
> list * __fill = &__tmp[0];
> list * __counter;
>
> do
> {
> __carry.splice(__carry.begin(), *this, begin());
>
> for(__counter = &__tmp[0];
> __counter != __fill && !__counter->empty();
> ++__counter)
> {
> __counter->merge(__carry, __comp);
> __carry.swap(*__counter);
> }
> __carry.swap(*__counter);
> if (__counter == __fill)
> ++__fill;
> }
> while ( !empty() );
>
> for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
> __counter->merge(*(__counter - 1), __comp);
> swap(*(__fill - 1));
> }
> }
>
>
>}
># 65 "/usr/include/c++/4.8.2/list" 2 3
># 21 "../src/position.h" 2
>
>using namespace iwf;
>using history::targetHistory;
>
>
>
>typedef enum
>{
> stopped,
> scanning,
> paused
>}scanStatus;
>
>const bool unidirectionalScan = false;
>
>
>
>
>
>
>
>class pointData
>{
> friend std::ostream &operator << (std::ostream &, pointData &);
>
>public:
>
> static const uint32_t readRecordSize = 15;
> static const uint32_t writeRecordSize = 26;
>
> uint32_t ID;
> position pos;
> bool use;
>
>
> double detectionRatio;
> double alarmRatio;
> uint32_t repeats;
> rgain gain;
> rbw bandwidth;
> tpower power;
> uint32_t correctionOffset;
> double maxDetectDistance;
> double minDetectDistance;
> double maxCorrectDistance;
> double maxDeconvDistance;
> double minCorrection;
>
>
>
> bool detected;
> bool alarm;
> double detectedRatio;
> uint32_t detectedRepeats;
> rgain detectedGain;
> rbw detectedBandwidth;
> tpower detectedPower;
> time_t detectedTime;
> double detectedDistance;
> std::string dataFileName;
> std::string imageFileName;
>
> pointData();
> void setDetected(double r, double d);
> bool writeSelfToTargetFile(std::ostream &out);
> bool writeSelfToStateFile(std::ostream &out);
> bool writeSelfToStream(std::ostream &out);
> bool readSelfFromTargetFile(std::istream &in);
> bool readSelfFromStateFile(std::istream &in);
>};
>
>
>
>
>std::ostream & operator << (std::ostream &out, pointData &dat);
>std::ostream & operator << (std::ostream &out, position pos);
>std::istream & operator >> (std::istream &out, position pos);
>
>namespace history
>{
> class targetHistory;
>}
>class interfaceSystem;
>class targetData;
>
>typedef std::map<uint32_t, pointData> pointMap;
>class pointMatrix
>{
> pointMap points;
> std::string name;
>};
>typedef std::list<pointMatrix> pointMatrixList;
>typedef std::list<tpower> powerList;
>
>
>
>struct pointState
>{
> rgain gain;
> rbw bandwidth;
> tpower power;
>
> pointState(pointData p):gain(p.gain), bandwidth(p.bandwidth), power(p.power) {};
> pointState(void):gain(g1), bandwidth(bw200), power(0) {};
> pointState &operator =(const pointState &p2){power = p2.power; gain = p2.gain; bandwidth = p2.bandwidth; return *this;};
>};
>
>inline bool operator ==(const pointState &p1, const pointState &p2){return (p1.power == p2.power and p1.gain == p2.gain and p1.bandwidth == p2.bandwidth);};
>bool operator <(const pointState &p1, const pointState &p2);
>typedef std::list<pointState> stateList;
>
>
>
>class positioner
>{
>private:
> iWCCclass *iWCC;
> targetHistory *tHistory;
> interfaceSystem *interface;
>
> pointMatrixList matrixList;
> uint32_t pointCount;
> uint32_t currentPoint;
> bool countUp;
> bool fullCircle;
> pointMap points;
> std::string pointsName;
> void goToCurrentPosition();
>
>public:
> position currentPosition;
>
> positioner(iWCCclass *i, history::targetHistory *h, interfaceSystem *is);
> void goToPosition(position p);
> position getPosition();
>
>
>
> void initialisePoints(double start, double stop, double step);
> void clearPoints() { points.clear(); pointCount = 0;};
> void setPoint(position p);
> void setPoint(pointData pd);
> pointData getPointData(uint32_t p);
> void setPointData(uint32_t p, pointData dat);
> uint32_t getPoint();
> bool movePosition(bool clockwise = true);
> void incrementPosition(bool forward = true);
> void goToPoint(uint32_t point);
> uint32_t getPointCount(void){return pointCount;};
> bool getScanDirection(){return countUp;};
> bool isScanEnd(void);
> bool doScanEndProcessing(void);
> bool scanForTargets(std::list<targetData *> &result);
> powerList *getUsedPowers(void);
> stateList *getUsedStates(void);
>};
>
>class measurementSettings;
>namespace iwf
>{
> class wildfireStatus;
>}
>
>void setupPoints(iwf::wildfireStatus &stats, measurementSettings &settings);
>double normalise360(double in);
>double normalise180(double in);
># 18 "../src/measure.h" 2
># 1 "../src/correlation.h" 1
># 14 "../src/correlation.h"
># 1 "/usr/include/fftw3.h" 1 3 4
># 53 "/usr/include/fftw3.h" 3 4
>extern "C"
>{
># 89 "/usr/include/fftw3.h" 3 4
>enum fftw_r2r_kind_do_not_use_me {
> FFTW_R2HC=0, FFTW_HC2R=1, FFTW_DHT=2,
> FFTW_REDFT00=3, FFTW_REDFT01=4, FFTW_REDFT10=5, FFTW_REDFT11=6,
> FFTW_RODFT00=7, FFTW_RODFT01=8, FFTW_RODFT10=9, FFTW_RODFT11=10
>};
>
>struct fftw_iodim_do_not_use_me {
> int n;
> int is;
> int os;
>};
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 102 "/usr/include/fftw3.h" 2 3 4
>struct fftw_iodim64_do_not_use_me {
> ptrdiff_t n;
> ptrdiff_t is;
> ptrdiff_t os;
>};
>
>typedef void (*fftw_write_char_func_do_not_use_me)(char c, void *);
>typedef int (*fftw_read_char_func_do_not_use_me)(void *);
># 353 "/usr/include/fftw3.h" 3 4
>typedef double fftw_complex[2]; typedef struct fftw_plan_s *fftw_plan; typedef struct fftw_iodim_do_not_use_me fftw_iodim; typedef struct fftw_iodim64_do_not_use_me fftw_iodim64; typedef enum fftw_r2r_kind_do_not_use_me fftw_r2r_kind; typedef fftw_write_char_func_do_not_use_me fftw_write_char_func; typedef fftw_read_char_func_do_not_use_me fftw_read_char_func; extern void fftw_execute(const fftw_plan p); extern fftw_plan fftw_plan_dft(int rank, const int *n, fftw_complex *in, fftw_complex *out, int sign, unsigned flags); extern fftw_plan fftw_plan_dft_1d(int n, fftw_complex *in, fftw_complex *out, int sign, unsigned flags); extern fftw_plan fftw_plan_dft_2d(int n0, int n1, fftw_complex *in, fftw_complex *out, int sign, unsigned flags); extern fftw_plan fftw_plan_dft_3d(int n0, int n1, int n2, fftw_complex *in, fftw_complex *out, int sign, unsigned flags); extern fftw_plan fftw_plan_many_dft(int rank, const int *n, int howmany, fftw_complex *in, const int *inembed, int istride, int idist, fftw_complex *out, const int *onembed, int ostride, int odist, int sign, unsigned flags); extern fftw_plan fftw_plan_guru_dft(int rank, const fftw_iodim *dims, int howmany_rank, const fftw_iodim *howmany_dims, fftw_complex *in, fftw_complex *out, int sign, unsigned flags); extern fftw_plan fftw_plan_guru_split_dft(int rank, const fftw_iodim *dims, int howmany_rank, const fftw_iodim *howmany_dims, double *ri, double *ii, double *ro, double *io, unsigned flags); extern fftw_plan fftw_plan_guru64_dft(int rank, const fftw_iodim64 *dims, int howmany_rank, const fftw_iodim64 *howmany_dims, fftw_complex *in, fftw_complex *out, int sign, unsigned flags); extern fftw_plan fftw_plan_guru64_split_dft(int rank, const fftw_iodim64 *dims, int howmany_rank, const fftw_iodim64 *howmany_dims, double *ri, double *ii, double *ro, double *io, unsigned flags); extern void fftw_execute_dft(const fftw_plan p, fftw_complex *in, fftw_complex *out); extern void fftw_execute_split_dft(const fftw_plan p, double *ri, double *ii, double *ro, double *io); extern fftw_plan fftw_plan_many_dft_r2c(int rank, const int *n, int howmany, double *in, const int *inembed, int istride, int idist, fftw_complex *out, const int *onembed, int ostride, int odist, unsigned flags); extern fftw_plan fftw_plan_dft_r2c(int rank, const int *n, double *in, fftw_complex *out, unsigned flags); extern fftw_plan fftw_plan_dft_r2c_1d(int n,double *in,fftw_complex *out,unsigned flags); extern fftw_plan fftw_plan_dft_r2c_2d(int n0, int n1, double *in, fftw_complex *out, unsigned flags); extern fftw_plan fftw_plan_dft_r2c_3d(int n0, int n1, int n2, double *in, fftw_complex *out, unsigned flags); extern fftw_plan fftw_plan_many_dft_c2r(int rank, const int *n, int howmany, fftw_complex *in, const int *inembed, int istride, int idist, double *out, const int *onembed, int ostride, int odist, unsigned flags); extern fftw_plan fftw_plan_dft_c2r(int rank, const int *n, fftw_complex *in, double *out, unsigned flags); extern fftw_plan fftw_plan_dft_c2r_1d(int n,fftw_complex *in,double *out,unsigned flags); extern fftw_plan fftw_plan_dft_c2r_2d(int n0, int n1, fftw_complex *in, double *out, unsigned flags); extern fftw_plan fftw_plan_dft_c2r_3d(int n0, int n1, int n2, fftw_complex *in, double *out, unsigned flags); extern fftw_plan fftw_plan_guru_dft_r2c(int rank, const fftw_iodim *dims, int howmany_rank, const fftw_iodim *howmany_dims, double *in, fftw_complex *out, unsigned flags); extern fftw_plan fftw_plan_guru_dft_c2r(int rank, const fftw_iodim *dims, int howmany_rank, const fftw_iodim *howmany_dims, fftw_complex *in, double *out, unsigned flags); extern fftw_plan fftw_plan_guru_split_dft_r2c( int rank, const fftw_iodim *dims, int howmany_rank, const fftw_iodim *howmany_dims, double *in, double *ro, double *io, unsigned flags); extern fftw_plan fftw_plan_guru_split_dft_c2r( int rank, const fftw_iodim *dims, int howmany_rank, const fftw_iodim *howmany_dims, double *ri, double *ii, double *out, unsigned flags); extern fftw_plan fftw_plan_guru64_dft_r2c(int rank, const fftw_iodim64 *dims, int howmany_rank, const fftw_iodim64 *howmany_dims, double *in, fftw_complex *out, unsigned flags); extern fftw_plan fftw_plan_guru64_dft_c2r(int rank, const fftw_iodim64 *dims, int howmany_rank, const fftw_iodim64 *howmany_dims, fftw_complex *in, double *out, unsigned flags); extern fftw_plan fftw_plan_guru64_split_dft_r2c( int rank, const fftw_iodim64 *dims, int howmany_rank, const fftw_iodim64 *howmany_dims, double *in, double *ro, double *io, unsigned flags); extern fftw_plan fftw_plan_guru64_split_dft_c2r( int rank, const fftw_iodim64 *dims, int howmany_rank, const fftw_iodim64 *howmany_dims, double *ri, double *ii, double *out, unsigned flags); extern void fftw_execute_dft_r2c(const fftw_plan p, double *in, fftw_complex *out); extern void fftw_execute_dft_c2r(const fftw_plan p, fftw_complex *in, double *out); extern void fftw_execute_split_dft_r2c(const fftw_plan p, double *in, double *ro, double *io); extern void fftw_execute_split_dft_c2r(const fftw_plan p, double *ri, double *ii, double *out); extern fftw_plan fftw_plan_many_r2r(int rank, const int *n, int howmany, double *in, const int *inembed, int istride, int idist, double *out, const int *onembed, int ostride, int odist, const fftw_r2r_kind *kind, unsigned flags); extern fftw_plan fftw_plan_r2r(int rank, const int *n, double *in, double *out, const fftw_r2r_kind *kind, unsigned flags); extern fftw_plan fftw_plan_r2r_1d(int n, double *in, double *out, fftw_r2r_kind kind, unsigned flags); extern fftw_plan fftw_plan_r2r_2d(int n0, int n1, double *in, double *out, fftw_r2r_kind kind0, fftw_r2r_kind kind1, unsigned flags); extern fftw_plan fftw_plan_r2r_3d(int n0, int n1, int n2, double *in, double *out, fftw_r2r_kind kind0, fftw_r2r_kind kind1, fftw_r2r_kind kind2, unsigned flags); extern fftw_plan fftw_plan_guru_r2r(int rank, const fftw_iodim *dims, int howmany_rank, const fftw_iodim *howmany_dims, double *in, double *out, const fftw_r2r_kind *kind, unsigned flags); extern fftw_plan fftw_plan_guru64_r2r(int rank, const fftw_iodim64 *dims, int howmany_rank, const fftw_iodim64 *howmany_dims, double *in, double *out, const fftw_r2r_kind *kind, unsigned flags); extern void fftw_execute_r2r(const fftw_plan p, double *in, double *out); extern void fftw_destroy_plan(fftw_plan p); extern void fftw_forget_wisdom(void); extern void fftw_cleanup(void); extern void fftw_set_timelimit(double t); extern void fftw_plan_with_nthreads(int nthreads); extern int fftw_init_threads(void); extern void fftw_cleanup_threads(void); extern int fftw_export_wisdom_to_filename(const char *filename); extern void fftw_export_wisdom_to_file(FILE *output_file); extern char *fftw_export_wisdom_to_string(void); extern void fftw_export_wisdom(fftw_write_char_func write_char, void *data); extern int fftw_import_system_wisdom(void); extern int fftw_import_wisdom_from_filename(const char *filename); extern int fftw_import_wisdom_from_file(FILE *input_file); extern int fftw_import_wisdom_from_string(const char *input_string); extern int fftw_import_wisdom(fftw_read_char_func read_char, void *data); extern void fftw_fprint_plan(const fftw_plan p, FILE *output_file); extern void fftw_print_plan(const fftw_plan p); extern void *fftw_malloc(size_t n); extern double *fftw_alloc_real(size_t n); extern fftw_complex *fftw_alloc_complex(size_t n); extern void fftw_free(void *p); extern void fftw_flops(const fftw_plan p, double *add, double *mul, double *fmas); extern double fftw_estimate_cost(const fftw_plan p); extern double fftw_cost(const fftw_plan p); extern const char fftw_version[]; extern const char fftw_cc[]; extern const char fftw_codelet_optim[];
>typedef float fftwf_complex[2]; typedef struct fftwf_plan_s *fftwf_plan; typedef struct fftw_iodim_do_not_use_me fftwf_iodim; typedef struct fftw_iodim64_do_not_use_me fftwf_iodim64; typedef enum fftw_r2r_kind_do_not_use_me fftwf_r2r_kind; typedef fftw_write_char_func_do_not_use_me fftwf_write_char_func; typedef fftw_read_char_func_do_not_use_me fftwf_read_char_func; extern void fftwf_execute(const fftwf_plan p); extern fftwf_plan fftwf_plan_dft(int rank, const int *n, fftwf_complex *in, fftwf_complex *out, int sign, unsigned flags); extern fftwf_plan fftwf_plan_dft_1d(int n, fftwf_complex *in, fftwf_complex *out, int sign, unsigned flags); extern fftwf_plan fftwf_plan_dft_2d(int n0, int n1, fftwf_complex *in, fftwf_complex *out, int sign, unsigned flags); extern fftwf_plan fftwf_plan_dft_3d(int n0, int n1, int n2, fftwf_complex *in, fftwf_complex *out, int sign, unsigned flags); extern fftwf_plan fftwf_plan_many_dft(int rank, const int *n, int howmany, fftwf_complex *in, const int *inembed, int istride, int idist, fftwf_complex *out, const int *onembed, int ostride, int odist, int sign, unsigned flags); extern fftwf_plan fftwf_plan_guru_dft(int rank, const fftwf_iodim *dims, int howmany_rank, const fftwf_iodim *howmany_dims, fftwf_complex *in, fftwf_complex *out, int sign, unsigned flags); extern fftwf_plan fftwf_plan_guru_split_dft(int rank, const fftwf_iodim *dims, int howmany_rank, const fftwf_iodim *howmany_dims, float *ri, float *ii, float *ro, float *io, unsigned flags); extern fftwf_plan fftwf_plan_guru64_dft(int rank, const fftwf_iodim64 *dims, int howmany_rank, const fftwf_iodim64 *howmany_dims, fftwf_complex *in, fftwf_complex *out, int sign, unsigned flags); extern fftwf_plan fftwf_plan_guru64_split_dft(int rank, const fftwf_iodim64 *dims, int howmany_rank, const fftwf_iodim64 *howmany_dims, float *ri, float *ii, float *ro, float *io, unsigned flags); extern void fftwf_execute_dft(const fftwf_plan p, fftwf_complex *in, fftwf_complex *out); extern void fftwf_execute_split_dft(const fftwf_plan p, float *ri, float *ii, float *ro, float *io); extern fftwf_plan fftwf_plan_many_dft_r2c(int rank, const int *n, int howmany, float *in, const int *inembed, int istride, int idist, fftwf_complex *out, const int *onembed, int ostride, int odist, unsigned flags); extern fftwf_plan fftwf_plan_dft_r2c(int rank, const int *n, float *in, fftwf_complex *out, unsigned flags); extern fftwf_plan fftwf_plan_dft_r2c_1d(int n,float *in,fftwf_complex *out,unsigned flags); extern fftwf_plan fftwf_plan_dft_r2c_2d(int n0, int n1, float *in, fftwf_complex *out, unsigned flags); extern fftwf_plan fftwf_plan_dft_r2c_3d(int n0, int n1, int n2, float *in, fftwf_complex *out, unsigned flags); extern fftwf_plan fftwf_plan_many_dft_c2r(int rank, const int *n, int howmany, fftwf_complex *in, const int *inembed, int istride, int idist, float *out, const int *onembed, int ostride, int odist, unsigned flags); extern fftwf_plan fftwf_plan_dft_c2r(int rank, const int *n, fftwf_complex *in, float *out, unsigned flags); extern fftwf_plan fftwf_plan_dft_c2r_1d(int n,fftwf_complex *in,float *out,unsigned flags); extern fftwf_plan fftwf_plan_dft_c2r_2d(int n0, int n1, fftwf_complex *in, float *out, unsigned flags); extern fftwf_plan fftwf_plan_dft_c2r_3d(int n0, int n1, int n2, fftwf_complex *in, float *out, unsigned flags); extern fftwf_plan fftwf_plan_guru_dft_r2c(int rank, const fftwf_iodim *dims, int howmany_rank, const fftwf_iodim *howmany_dims, float *in, fftwf_complex *out, unsigned flags); extern fftwf_plan fftwf_plan_guru_dft_c2r(int rank, const fftwf_iodim *dims, int howmany_rank, const fftwf_iodim *howmany_dims, fftwf_complex *in, float *out, unsigned flags); extern fftwf_plan fftwf_plan_guru_split_dft_r2c( int rank, const fftwf_iodim *dims, int howmany_rank, const fftwf_iodim *howmany_dims, float *in, float *ro, float *io, unsigned flags); extern fftwf_plan fftwf_plan_guru_split_dft_c2r( int rank, const fftwf_iodim *dims, int howmany_rank, const fftwf_iodim *howmany_dims, float *ri, float *ii, float *out, unsigned flags); extern fftwf_plan fftwf_plan_guru64_dft_r2c(int rank, const fftwf_iodim64 *dims, int howmany_rank, const fftwf_iodim64 *howmany_dims, float *in, fftwf_complex *out, unsigned flags); extern fftwf_plan fftwf_plan_guru64_dft_c2r(int rank, const fftwf_iodim64 *dims, int howmany_rank, const fftwf_iodim64 *howmany_dims, fftwf_complex *in, float *out, unsigned flags); extern fftwf_plan fftwf_plan_guru64_split_dft_r2c( int rank, const fftwf_iodim64 *dims, int howmany_rank, const fftwf_iodim64 *howmany_dims, float *in, float *ro, float *io, unsigned flags); extern fftwf_plan fftwf_plan_guru64_split_dft_c2r( int rank, const fftwf_iodim64 *dims, int howmany_rank, const fftwf_iodim64 *howmany_dims, float *ri, float *ii, float *out, unsigned flags); extern void fftwf_execute_dft_r2c(const fftwf_plan p, float *in, fftwf_complex *out); extern void fftwf_execute_dft_c2r(const fftwf_plan p, fftwf_complex *in, float *out); extern void fftwf_execute_split_dft_r2c(const fftwf_plan p, float *in, float *ro, float *io); extern void fftwf_execute_split_dft_c2r(const fftwf_plan p, float *ri, float *ii, float *out); extern fftwf_plan fftwf_plan_many_r2r(int rank, const int *n, int howmany, float *in, const int *inembed, int istride, int idist, float *out, const int *onembed, int ostride, int odist, const fftwf_r2r_kind *kind, unsigned flags); extern fftwf_plan fftwf_plan_r2r(int rank, const int *n, float *in, float *out, const fftwf_r2r_kind *kind, unsigned flags); extern fftwf_plan fftwf_plan_r2r_1d(int n, float *in, float *out, fftwf_r2r_kind kind, unsigned flags); extern fftwf_plan fftwf_plan_r2r_2d(int n0, int n1, float *in, float *out, fftwf_r2r_kind kind0, fftwf_r2r_kind kind1, unsigned flags); extern fftwf_plan fftwf_plan_r2r_3d(int n0, int n1, int n2, float *in, float *out, fftwf_r2r_kind kind0, fftwf_r2r_kind kind1, fftwf_r2r_kind kind2, unsigned flags); extern fftwf_plan fftwf_plan_guru_r2r(int rank, const fftwf_iodim *dims, int howmany_rank, const fftwf_iodim *howmany_dims, float *in, float *out, const fftwf_r2r_kind *kind, unsigned flags); extern fftwf_plan fftwf_plan_guru64_r2r(int rank, const fftwf_iodim64 *dims, int howmany_rank, const fftwf_iodim64 *howmany_dims, float *in, float *out, const fftwf_r2r_kind *kind, unsigned flags); extern void fftwf_execute_r2r(const fftwf_plan p, float *in, float *out); extern void fftwf_destroy_plan(fftwf_plan p); extern void fftwf_forget_wisdom(void); extern void fftwf_cleanup(void); extern void fftwf_set_timelimit(double t); extern void fftwf_plan_with_nthreads(int nthreads); extern int fftwf_init_threads(void); extern void fftwf_cleanup_threads(void); extern int fftwf_export_wisdom_to_filename(const char *filename); extern void fftwf_export_wisdom_to_file(FILE *output_file); extern char *fftwf_export_wisdom_to_string(void); extern void fftwf_export_wisdom(fftwf_write_char_func write_char, void *data); extern int fftwf_import_system_wisdom(void); extern int fftwf_import_wisdom_from_filename(const char *filename); extern int fftwf_import_wisdom_from_file(FILE *input_file); extern int fftwf_import_wisdom_from_string(const char *input_string); extern int fftwf_import_wisdom(fftwf_read_char_func read_char, void *data); extern void fftwf_fprint_plan(const fftwf_plan p, FILE *output_file); extern void fftwf_print_plan(const fftwf_plan p); extern void *fftwf_malloc(size_t n); extern float *fftwf_alloc_real(size_t n); extern fftwf_complex *fftwf_alloc_complex(size_t n); extern void fftwf_free(void *p); extern void fftwf_flops(const fftwf_plan p, double *add, double *mul, double *fmas); extern double fftwf_estimate_cost(const fftwf_plan p); extern double fftwf_cost(const fftwf_plan p); extern const char fftwf_version[]; extern const char fftwf_cc[]; extern const char fftwf_codelet_optim[];
>typedef long double fftwl_complex[2]; typedef struct fftwl_plan_s *fftwl_plan; typedef struct fftw_iodim_do_not_use_me fftwl_iodim; typedef struct fftw_iodim64_do_not_use_me fftwl_iodim64; typedef enum fftw_r2r_kind_do_not_use_me fftwl_r2r_kind; typedef fftw_write_char_func_do_not_use_me fftwl_write_char_func; typedef fftw_read_char_func_do_not_use_me fftwl_read_char_func; extern void fftwl_execute(const fftwl_plan p); extern fftwl_plan fftwl_plan_dft(int rank, const int *n, fftwl_complex *in, fftwl_complex *out, int sign, unsigned flags); extern fftwl_plan fftwl_plan_dft_1d(int n, fftwl_complex *in, fftwl_complex *out, int sign, unsigned flags); extern fftwl_plan fftwl_plan_dft_2d(int n0, int n1, fftwl_complex *in, fftwl_complex *out, int sign, unsigned flags); extern fftwl_plan fftwl_plan_dft_3d(int n0, int n1, int n2, fftwl_complex *in, fftwl_complex *out, int sign, unsigned flags); extern fftwl_plan fftwl_plan_many_dft(int rank, const int *n, int howmany, fftwl_complex *in, const int *inembed, int istride, int idist, fftwl_complex *out, const int *onembed, int ostride, int odist, int sign, unsigned flags); extern fftwl_plan fftwl_plan_guru_dft(int rank, const fftwl_iodim *dims, int howmany_rank, const fftwl_iodim *howmany_dims, fftwl_complex *in, fftwl_complex *out, int sign, unsigned flags); extern fftwl_plan fftwl_plan_guru_split_dft(int rank, const fftwl_iodim *dims, int howmany_rank, const fftwl_iodim *howmany_dims, long double *ri, long double *ii, long double *ro, long double *io, unsigned flags); extern fftwl_plan fftwl_plan_guru64_dft(int rank, const fftwl_iodim64 *dims, int howmany_rank, const fftwl_iodim64 *howmany_dims, fftwl_complex *in, fftwl_complex *out, int sign, unsigned flags); extern fftwl_plan fftwl_plan_guru64_split_dft(int rank, const fftwl_iodim64 *dims, int howmany_rank, const fftwl_iodim64 *howmany_dims, long double *ri, long double *ii, long double *ro, long double *io, unsigned flags); extern void fftwl_execute_dft(const fftwl_plan p, fftwl_complex *in, fftwl_complex *out); extern void fftwl_execute_split_dft(const fftwl_plan p, long double *ri, long double *ii, long double *ro, long double *io); extern fftwl_plan fftwl_plan_many_dft_r2c(int rank, const int *n, int howmany, long double *in, const int *inembed, int istride, int idist, fftwl_complex *out, const int *onembed, int ostride, int odist, unsigned flags); extern fftwl_plan fftwl_plan_dft_r2c(int rank, const int *n, long double *in, fftwl_complex *out, unsigned flags); extern fftwl_plan fftwl_plan_dft_r2c_1d(int n,long double *in,fftwl_complex *out,unsigned flags); extern fftwl_plan fftwl_plan_dft_r2c_2d(int n0, int n1, long double *in, fftwl_complex *out, unsigned flags); extern fftwl_plan fftwl_plan_dft_r2c_3d(int n0, int n1, int n2, long double *in, fftwl_complex *out, unsigned flags); extern fftwl_plan fftwl_plan_many_dft_c2r(int rank, const int *n, int howmany, fftwl_complex *in, const int *inembed, int istride, int idist, long double *out, const int *onembed, int ostride, int odist, unsigned flags); extern fftwl_plan fftwl_plan_dft_c2r(int rank, const int *n, fftwl_complex *in, long double *out, unsigned flags); extern fftwl_plan fftwl_plan_dft_c2r_1d(int n,fftwl_complex *in,long double *out,unsigned flags); extern fftwl_plan fftwl_plan_dft_c2r_2d(int n0, int n1, fftwl_complex *in, long double *out, unsigned flags); extern fftwl_plan fftwl_plan_dft_c2r_3d(int n0, int n1, int n2, fftwl_complex *in, long double *out, unsigned flags); extern fftwl_plan fftwl_plan_guru_dft_r2c(int rank, const fftwl_iodim *dims, int howmany_rank, const fftwl_iodim *howmany_dims, long double *in, fftwl_complex *out, unsigned flags); extern fftwl_plan fftwl_plan_guru_dft_c2r(int rank, const fftwl_iodim *dims, int howmany_rank, const fftwl_iodim *howmany_dims, fftwl_complex *in, long double *out, unsigned flags); extern fftwl_plan fftwl_plan_guru_split_dft_r2c( int rank, const fftwl_iodim *dims, int howmany_rank, const fftwl_iodim *howmany_dims, long double *in, long double *ro, long double *io, unsigned flags); extern fftwl_plan fftwl_plan_guru_split_dft_c2r( int rank, const fftwl_iodim *dims, int howmany_rank, const fftwl_iodim *howmany_dims, long double *ri, long double *ii, long double *out, unsigned flags); extern fftwl_plan fftwl_plan_guru64_dft_r2c(int rank, const fftwl_iodim64 *dims, int howmany_rank, const fftwl_iodim64 *howmany_dims, long double *in, fftwl_complex *out, unsigned flags); extern fftwl_plan fftwl_plan_guru64_dft_c2r(int rank, const fftwl_iodim64 *dims, int howmany_rank, const fftwl_iodim64 *howmany_dims, fftwl_complex *in, long double *out, unsigned flags); extern fftwl_plan fftwl_plan_guru64_split_dft_r2c( int rank, const fftwl_iodim64 *dims, int howmany_rank, const fftwl_iodim64 *howmany_dims, long double *in, long double *ro, long double *io, unsigned flags); extern fftwl_plan fftwl_plan_guru64_split_dft_c2r( int rank, const fftwl_iodim64 *dims, int howmany_rank, const fftwl_iodim64 *howmany_dims, long double *ri, long double *ii, long double *out, unsigned flags); extern void fftwl_execute_dft_r2c(const fftwl_plan p, long double *in, fftwl_complex *out); extern void fftwl_execute_dft_c2r(const fftwl_plan p, fftwl_complex *in, long double *out); extern void fftwl_execute_split_dft_r2c(const fftwl_plan p, long double *in, long double *ro, long double *io); extern void fftwl_execute_split_dft_c2r(const fftwl_plan p, long double *ri, long double *ii, long double *out); extern fftwl_plan fftwl_plan_many_r2r(int rank, const int *n, int howmany, long double *in, const int *inembed, int istride, int idist, long double *out, const int *onembed, int ostride, int odist, const fftwl_r2r_kind *kind, unsigned flags); extern fftwl_plan fftwl_plan_r2r(int rank, const int *n, long double *in, long double *out, const fftwl_r2r_kind *kind, unsigned flags); extern fftwl_plan fftwl_plan_r2r_1d(int n, long double *in, long double *out, fftwl_r2r_kind kind, unsigned flags); extern fftwl_plan fftwl_plan_r2r_2d(int n0, int n1, long double *in, long double *out, fftwl_r2r_kind kind0, fftwl_r2r_kind kind1, unsigned flags); extern fftwl_plan fftwl_plan_r2r_3d(int n0, int n1, int n2, long double *in, long double *out, fftwl_r2r_kind kind0, fftwl_r2r_kind kind1, fftwl_r2r_kind kind2, unsigned flags); extern fftwl_plan fftwl_plan_guru_r2r(int rank, const fftwl_iodim *dims, int howmany_rank, const fftwl_iodim *howmany_dims, long double *in, long double *out, const fftwl_r2r_kind *kind, unsigned flags); extern fftwl_plan fftwl_plan_guru64_r2r(int rank, const fftwl_iodim64 *dims, int howmany_rank, const fftwl_iodim64 *howmany_dims, long double *in, long double *out, const fftwl_r2r_kind *kind, unsigned flags); extern void fftwl_execute_r2r(const fftwl_plan p, long double *in, long double *out); extern void fftwl_destroy_plan(fftwl_plan p); extern void fftwl_forget_wisdom(void); extern void fftwl_cleanup(void); extern void fftwl_set_timelimit(double t); extern void fftwl_plan_with_nthreads(int nthreads); extern int fftwl_init_threads(void); extern void fftwl_cleanup_threads(void); extern int fftwl_export_wisdom_to_filename(const char *filename); extern void fftwl_export_wisdom_to_file(FILE *output_file); extern char *fftwl_export_wisdom_to_string(void); extern void fftwl_export_wisdom(fftwl_write_char_func write_char, void *data); extern int fftwl_import_system_wisdom(void); extern int fftwl_import_wisdom_from_filename(const char *filename); extern int fftwl_import_wisdom_from_file(FILE *input_file); extern int fftwl_import_wisdom_from_string(const char *input_string); extern int fftwl_import_wisdom(fftwl_read_char_func read_char, void *data); extern void fftwl_fprint_plan(const fftwl_plan p, FILE *output_file); extern void fftwl_print_plan(const fftwl_plan p); extern void *fftwl_malloc(size_t n); extern long double *fftwl_alloc_real(size_t n); extern fftwl_complex *fftwl_alloc_complex(size_t n); extern void fftwl_free(void *p); extern void fftwl_flops(const fftwl_plan p, double *add, double *mul, double *fmas); extern double fftwl_estimate_cost(const fftwl_plan p); extern double fftwl_cost(const fftwl_plan p); extern const char fftwl_version[]; extern const char fftwl_cc[]; extern const char fftwl_codelet_optim[];
># 371 "/usr/include/fftw3.h" 3 4
>typedef __float128 fftwq_complex[2]; typedef struct fftwq_plan_s *fftwq_plan; typedef struct fftw_iodim_do_not_use_me fftwq_iodim; typedef struct fftw_iodim64_do_not_use_me fftwq_iodim64; typedef enum fftw_r2r_kind_do_not_use_me fftwq_r2r_kind; typedef fftw_write_char_func_do_not_use_me fftwq_write_char_func; typedef fftw_read_char_func_do_not_use_me fftwq_read_char_func; extern void fftwq_execute(const fftwq_plan p); extern fftwq_plan fftwq_plan_dft(int rank, const int *n, fftwq_complex *in, fftwq_complex *out, int sign, unsigned flags); extern fftwq_plan fftwq_plan_dft_1d(int n, fftwq_complex *in, fftwq_complex *out, int sign, unsigned flags); extern fftwq_plan fftwq_plan_dft_2d(int n0, int n1, fftwq_complex *in, fftwq_complex *out, int sign, unsigned flags); extern fftwq_plan fftwq_plan_dft_3d(int n0, int n1, int n2, fftwq_complex *in, fftwq_complex *out, int sign, unsigned flags); extern fftwq_plan fftwq_plan_many_dft(int rank, const int *n, int howmany, fftwq_complex *in, const int *inembed, int istride, int idist, fftwq_complex *out, const int *onembed, int ostride, int odist, int sign, unsigned flags); extern fftwq_plan fftwq_plan_guru_dft(int rank, const fftwq_iodim *dims, int howmany_rank, const fftwq_iodim *howmany_dims, fftwq_complex *in, fftwq_complex *out, int sign, unsigned flags); extern fftwq_plan fftwq_plan_guru_split_dft(int rank, const fftwq_iodim *dims, int howmany_rank, const fftwq_iodim *howmany_dims, __float128 *ri, __float128 *ii, __float128 *ro, __float128 *io, unsigned flags); extern fftwq_plan fftwq_plan_guru64_dft(int rank, const fftwq_iodim64 *dims, int howmany_rank, const fftwq_iodim64 *howmany_dims, fftwq_complex *in, fftwq_complex *out, int sign, unsigned flags); extern fftwq_plan fftwq_plan_guru64_split_dft(int rank, const fftwq_iodim64 *dims, int howmany_rank, const fftwq_iodim64 *howmany_dims, __float128 *ri, __float128 *ii, __float128 *ro, __float128 *io, unsigned flags); extern void fftwq_execute_dft(const fftwq_plan p, fftwq_complex *in, fftwq_complex *out); extern void fftwq_execute_split_dft(const fftwq_plan p, __float128 *ri, __float128 *ii, __float128 *ro, __float128 *io); extern fftwq_plan fftwq_plan_many_dft_r2c(int rank, const int *n, int howmany, __float128 *in, const int *inembed, int istride, int idist, fftwq_complex *out, const int *onembed, int ostride, int odist, unsigned flags); extern fftwq_plan fftwq_plan_dft_r2c(int rank, const int *n, __float128 *in, fftwq_complex *out, unsigned flags); extern fftwq_plan fftwq_plan_dft_r2c_1d(int n,__float128 *in,fftwq_complex *out,unsigned flags); extern fftwq_plan fftwq_plan_dft_r2c_2d(int n0, int n1, __float128 *in, fftwq_complex *out, unsigned flags); extern fftwq_plan fftwq_plan_dft_r2c_3d(int n0, int n1, int n2, __float128 *in, fftwq_complex *out, unsigned flags); extern fftwq_plan fftwq_plan_many_dft_c2r(int rank, const int *n, int howmany, fftwq_complex *in, const int *inembed, int istride, int idist, __float128 *out, const int *onembed, int ostride, int odist, unsigned flags); extern fftwq_plan fftwq_plan_dft_c2r(int rank, const int *n, fftwq_complex *in, __float128 *out, unsigned flags); extern fftwq_plan fftwq_plan_dft_c2r_1d(int n,fftwq_complex *in,__float128 *out,unsigned flags); extern fftwq_plan fftwq_plan_dft_c2r_2d(int n0, int n1, fftwq_complex *in, __float128 *out, unsigned flags); extern fftwq_plan fftwq_plan_dft_c2r_3d(int n0, int n1, int n2, fftwq_complex *in, __float128 *out, unsigned flags); extern fftwq_plan fftwq_plan_guru_dft_r2c(int rank, const fftwq_iodim *dims, int howmany_rank, const fftwq_iodim *howmany_dims, __float128 *in, fftwq_complex *out, unsigned flags); extern fftwq_plan fftwq_plan_guru_dft_c2r(int rank, const fftwq_iodim *dims, int howmany_rank, const fftwq_iodim *howmany_dims, fftwq_complex *in, __float128 *out, unsigned flags); extern fftwq_plan fftwq_plan_guru_split_dft_r2c( int rank, const fftwq_iodim *dims, int howmany_rank, const fftwq_iodim *howmany_dims, __float128 *in, __float128 *ro, __float128 *io, unsigned flags); extern fftwq_plan fftwq_plan_guru_split_dft_c2r( int rank, const fftwq_iodim *dims, int howmany_rank, const fftwq_iodim *howmany_dims, __float128 *ri, __float128 *ii, __float128 *out, unsigned flags); extern fftwq_plan fftwq_plan_guru64_dft_r2c(int rank, const fftwq_iodim64 *dims, int howmany_rank, const fftwq_iodim64 *howmany_dims, __float128 *in, fftwq_complex *out, unsigned flags); extern fftwq_plan fftwq_plan_guru64_dft_c2r(int rank, const fftwq_iodim64 *dims, int howmany_rank, const fftwq_iodim64 *howmany_dims, fftwq_complex *in, __float128 *out, unsigned flags); extern fftwq_plan fftwq_plan_guru64_split_dft_r2c( int rank, const fftwq_iodim64 *dims, int howmany_rank, const fftwq_iodim64 *howmany_dims, __float128 *in, __float128 *ro, __float128 *io, unsigned flags); extern fftwq_plan fftwq_plan_guru64_split_dft_c2r( int rank, const fftwq_iodim64 *dims, int howmany_rank, const fftwq_iodim64 *howmany_dims, __float128 *ri, __float128 *ii, __float128 *out, unsigned flags); extern void fftwq_execute_dft_r2c(const fftwq_plan p, __float128 *in, fftwq_complex *out); extern void fftwq_execute_dft_c2r(const fftwq_plan p, fftwq_complex *in, __float128 *out); extern void fftwq_execute_split_dft_r2c(const fftwq_plan p, __float128 *in, __float128 *ro, __float128 *io); extern void fftwq_execute_split_dft_c2r(const fftwq_plan p, __float128 *ri, __float128 *ii, __float128 *out); extern fftwq_plan fftwq_plan_many_r2r(int rank, const int *n, int howmany, __float128 *in, const int *inembed, int istride, int idist, __float128 *out, const int *onembed, int ostride, int odist, const fftwq_r2r_kind *kind, unsigned flags); extern fftwq_plan fftwq_plan_r2r(int rank, const int *n, __float128 *in, __float128 *out, const fftwq_r2r_kind *kind, unsigned flags); extern fftwq_plan fftwq_plan_r2r_1d(int n, __float128 *in, __float128 *out, fftwq_r2r_kind kind, unsigned flags); extern fftwq_plan fftwq_plan_r2r_2d(int n0, int n1, __float128 *in, __float128 *out, fftwq_r2r_kind kind0, fftwq_r2r_kind kind1, unsigned flags); extern fftwq_plan fftwq_plan_r2r_3d(int n0, int n1, int n2, __float128 *in, __float128 *out, fftwq_r2r_kind kind0, fftwq_r2r_kind kind1, fftwq_r2r_kind kind2, unsigned flags); extern fftwq_plan fftwq_plan_guru_r2r(int rank, const fftwq_iodim *dims, int howmany_rank, const fftwq_iodim *howmany_dims, __float128 *in, __float128 *out, const fftwq_r2r_kind *kind, unsigned flags); extern fftwq_plan fftwq_plan_guru64_r2r(int rank, const fftwq_iodim64 *dims, int howmany_rank, const fftwq_iodim64 *howmany_dims, __float128 *in, __float128 *out, const fftwq_r2r_kind *kind, unsigned flags); extern void fftwq_execute_r2r(const fftwq_plan p, __float128 *in, __float128 *out); extern void fftwq_destroy_plan(fftwq_plan p); extern void fftwq_forget_wisdom(void); extern void fftwq_cleanup(void); extern void fftwq_set_timelimit(double t); extern void fftwq_plan_with_nthreads(int nthreads); extern int fftwq_init_threads(void); extern void fftwq_cleanup_threads(void); extern int fftwq_export_wisdom_to_filename(const char *filename); extern void fftwq_export_wisdom_to_file(FILE *output_file); extern char *fftwq_export_wisdom_to_string(void); extern void fftwq_export_wisdom(fftwq_write_char_func write_char, void *data); extern int fftwq_import_system_wisdom(void); extern int fftwq_import_wisdom_from_filename(const char *filename); extern int fftwq_import_wisdom_from_file(FILE *input_file); extern int fftwq_import_wisdom_from_string(const char *input_string); extern int fftwq_import_wisdom(fftwq_read_char_func read_char, void *data); extern void fftwq_fprint_plan(const fftwq_plan p, FILE *output_file); extern void fftwq_print_plan(const fftwq_plan p); extern void *fftwq_malloc(size_t n); extern __float128 *fftwq_alloc_real(size_t n); extern fftwq_complex *fftwq_alloc_complex(size_t n); extern void fftwq_free(void *p); extern void fftwq_flops(const fftwq_plan p, double *add, double *mul, double *fmas); extern double fftwq_estimate_cost(const fftwq_plan p); extern double fftwq_cost(const fftwq_plan p); extern const char fftwq_version[]; extern const char fftwq_cc[]; extern const char fftwq_codelet_optim[];
># 407 "/usr/include/fftw3.h" 3 4
>}
># 15 "../src/correlation.h" 2
>
>
>
>
>namespace cal
>{
>}
>
>struct singlePowerCalData_t
>{
> tpower power;
> double *data;
>};
>typedef std::vector<singlePowerCalData_t> allCalData_t;
># 39 "../src/correlation.h"
> class correlate
> {
> public:
> correlate(const uint32_t size);
> ~correlate();
> const cplx *crossCorrelate(double *signal);
> void setCode(const double *code);
> bool performCalibration(tpower power);
> bool readInCalFile(uint32_t length);
> bool readInRefSignal(uint32_t length, measurementSettings &settings);
> void clearCalData(void);
> void setAllCalData(allCalData_t *data) {allCalData = data;};
>
> private:
> uint32_t size;
> double invSize;
> double sqrtInvSize;
> cplx *input1;
> cplx *input2;
> cplx *output;
> fftw_complex *input1f;
> fftw_complex *input2f;
> fftw_complex *outputf;
> fftw_plan p1;
> fftw_plan p2;
> fftw_plan p3;
> allCalData_t *allCalData;
> };
>
>class measurementSettings;
>void initialiseSignalProcessing(wildfireStatus &stats, measurementSettings &settings);
># 19 "../src/measure.h" 2
># 1 "../src/detect.h" 1
># 17 "../src/detect.h"
># 1 "/usr/include/c++/4.8.2/cstdlib" 1 3
># 39 "/usr/include/c++/4.8.2/cstdlib" 3
> 
># 40 "/usr/include/c++/4.8.2/cstdlib" 3
># 18 "../src/detect.h" 2
>
># 1 "../src/correlation.h" 1
># 20 "../src/detect.h" 2
># 28 "../src/detect.h"
># 1 "/usr/include/boost/multi_array.hpp" 1 3 4
># 21 "/usr/include/boost/multi_array.hpp" 3 4
># 1 "/usr/include/boost/multi_array/base.hpp" 1 3 4
># 21 "/usr/include/boost/multi_array/base.hpp" 3 4
># 1 "/usr/include/boost/multi_array/extent_range.hpp" 1 3 4
># 18 "/usr/include/boost/multi_array/extent_range.hpp" 3 4
>namespace boost {
>namespace detail {
>namespace multi_array {
>
>template <typename Extent, typename SizeType>
>class extent_range : private std::pair<Extent,Extent> {
> typedef std::pair<Extent,Extent> super_type;
>public:
> typedef Extent index;
> typedef SizeType size_type;
>
> extent_range(index start, index finish) :
> super_type(start,finish) { }
>
> extent_range(index finish) :
> super_type(0,finish) { }
>
> extent_range() : super_type(0,0) { }
>
> index start() const { return super_type::first; }
>
> index finish() const { return super_type::second; }
>
> size_type size() const { return super_type::second - super_type::first; }
>};
>
>}
>}
>}
># 22 "/usr/include/boost/multi_array/base.hpp" 2 3 4
># 1 "/usr/include/boost/multi_array/extent_gen.hpp" 1 3 4
># 17 "/usr/include/boost/multi_array/extent_gen.hpp" 3 4
># 1 "/usr/include/boost/multi_array/range_list.hpp" 1 3 4
># 19 "/usr/include/boost/multi_array/range_list.hpp" 3 4
># 1 "/usr/include/boost/array.hpp" 1 3 4
># 42 "/usr/include/boost/array.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 43 "/usr/include/boost/array.hpp" 2 3 4
>
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 45 "/usr/include/boost/array.hpp" 2 3 4
># 1 "/usr/include/boost/swap.hpp" 1 3 4
># 10 "/usr/include/boost/swap.hpp" 3 4
># 1 "/usr/include/boost/utility/swap.hpp" 1 3 4
># 25 "/usr/include/boost/utility/swap.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 26 "/usr/include/boost/utility/swap.hpp" 2 3 4
>
>namespace boost_swap_impl
>{
> template<class T>
> void swap_impl(T& left, T& right)
> {
> using namespace std;
> swap(left,right);
> }
>
> template<class T, std::size_t N>
> void swap_impl(T (& left)[N], T (& right)[N])
> {
> for (std::size_t i = 0; i < N; ++i)
> {
> ::boost_swap_impl::swap_impl(left[i], right[i]);
> }
> }
>}
>
>namespace boost
>{
> template<class T1, class T2>
> void swap(T1& left, T2& right)
> {
> ::boost_swap_impl::swap_impl(left, right);
> }
>}
># 11 "/usr/include/boost/swap.hpp" 2 3 4
># 46 "/usr/include/boost/array.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/functional/hash_fwd.hpp" 1 3 4
>
>
>
>
>
># 1 "/usr/include/boost/functional/hash/hash_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/functional/hash/hash_fwd.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 19 "/usr/include/boost/functional/hash/hash_fwd.hpp" 2 3 4
>
>
>namespace boost
>{
> template <class T> struct hash;
>
>
>
>
> template <class T> void hash_combine(std::size_t& seed, T const& v);
>
>
> template <class It> std::size_t hash_range(It, It);
> template <class It> void hash_range(std::size_t&, It, It);
>
>
>
>
>
>}
># 7 "/usr/include/boost/functional/hash_fwd.hpp" 2 3 4
># 51 "/usr/include/boost/array.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost {
>
> template<class T, std::size_t N>
> class array {
> public:
> T elems[N];
>
> public:
>
> typedef T value_type;
> typedef T* iterator;
> typedef const T* const_iterator;
> typedef T& reference;
> typedef const T& const_reference;
> typedef std::size_t size_type;
> typedef std::ptrdiff_t difference_type;
>
>
> iterator begin() { return elems; }
> const_iterator begin() const { return elems; }
> const_iterator cbegin() const { return elems; }
>
> iterator end() { return elems+N; }
> const_iterator end() const { return elems+N; }
> const_iterator cend() const { return elems+N; }
>
>
>
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
># 104 "/usr/include/boost/array.hpp" 3 4
> reverse_iterator rbegin() { return reverse_iterator(end()); }
> const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
> const_reverse_iterator crbegin() const {
> return const_reverse_iterator(end());
> }
>
> reverse_iterator rend() { return reverse_iterator(begin()); }
> const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
> const_reverse_iterator crend() const {
> return const_reverse_iterator(begin());
> }
>
>
> reference operator[](size_type i)
> {
> ((void)0);
> return elems[i];
> }
>
> const_reference operator[](size_type i) const
> {
> ((void)0);
> return elems[i];
> }
>
>
> reference at(size_type i) { rangecheck(i); return elems[i]; }
> const_reference at(size_type i) const { rangecheck(i); return elems[i]; }
>
>
> reference front()
> {
> return elems[0];
> }
>
> const_reference front() const
> {
> return elems[0];
> }
>
> reference back()
> {
> return elems[N-1];
> }
>
> const_reference back() const
> {
> return elems[N-1];
> }
>
>
> static size_type size() { return N; }
> static bool empty() { return false; }
> static size_type max_size() { return N; }
> enum { static_size = N };
>
>
> void swap (array<T,N>& y) {
> for (size_type i = 0; i < N; ++i)
> boost::swap(elems[i],y.elems[i]);
> }
>
>
> const T* data() const { return elems; }
> T* data() { return elems; }
>
>
> T* c_array() { return elems; }
>
>
> template <typename T2>
> array<T,N>& operator= (const array<T2,N>& rhs) {
> std::copy(rhs.begin(),rhs.end(), begin());
> return *this;
> }
>
>
> void assign (const T& value) { fill ( value ); }
> void fill (const T& value)
> {
> std::fill_n(begin(),size(),value);
> }
>
>
> static void rangecheck (size_type i) {
> if (i >= size()) {
> std::out_of_range e("array<>: index out of range");
> boost::throw_exception(e);
> }
> }
>
> };
>
>
> template< class T >
> class array< T, 0 > {
>
> public:
>
> typedef T value_type;
> typedef T* iterator;
> typedef const T* const_iterator;
> typedef T& reference;
> typedef const T& const_reference;
> typedef std::size_t size_type;
> typedef std::ptrdiff_t difference_type;
>
>
> iterator begin() { return iterator( reinterpret_cast< T * >( this ) ); }
> const_iterator begin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
> const_iterator cbegin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
>
> iterator end() { return begin(); }
> const_iterator end() const { return begin(); }
> const_iterator cend() const { return cbegin(); }
>
>
>
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
># 245 "/usr/include/boost/array.hpp" 3 4
> reverse_iterator rbegin() { return reverse_iterator(end()); }
> const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
> const_reverse_iterator crbegin() const {
> return const_reverse_iterator(end());
> }
>
> reverse_iterator rend() { return reverse_iterator(begin()); }
> const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
> const_reverse_iterator crend() const {
> return const_reverse_iterator(begin());
> }
>
>
> reference operator[](size_type )
> {
> return failed_rangecheck();
> }
>
> const_reference operator[](size_type ) const
> {
> return failed_rangecheck();
> }
>
>
> reference at(size_type ) { return failed_rangecheck(); }
> const_reference at(size_type ) const { return failed_rangecheck(); }
>
>
> reference front()
> {
> return failed_rangecheck();
> }
>
> const_reference front() const
> {
> return failed_rangecheck();
> }
>
> reference back()
> {
> return failed_rangecheck();
> }
>
> const_reference back() const
> {
> return failed_rangecheck();
> }
>
>
> static size_type size() { return 0; }
> static bool empty() { return true; }
> static size_type max_size() { return 0; }
> enum { static_size = 0 };
>
> void swap (array<T,0>& ) {
> }
>
>
> const T* data() const { return 0; }
> T* data() { return 0; }
>
>
> T* c_array() { return 0; }
>
>
> template <typename T2>
> array<T,0>& operator= (const array<T2,0>& ) {
> return *this;
> }
>
>
> void assign (const T& value) { fill ( value ); }
> void fill (const T& ) {}
>
>
> static reference failed_rangecheck () {
> std::out_of_range e("attempt to access element of an empty array");
> boost::throw_exception(e);
>
>
>
>
>
>
> static T placeholder;
> return placeholder;
>
> }
> };
>
>
>
> template<class T, std::size_t N>
> bool operator== (const array<T,N>& x, const array<T,N>& y) {
> return std::equal(x.begin(), x.end(), y.begin());
> }
> template<class T, std::size_t N>
> bool operator< (const array<T,N>& x, const array<T,N>& y) {
> return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
> }
> template<class T, std::size_t N>
> bool operator!= (const array<T,N>& x, const array<T,N>& y) {
> return !(x==y);
> }
> template<class T, std::size_t N>
> bool operator> (const array<T,N>& x, const array<T,N>& y) {
> return y<x;
> }
> template<class T, std::size_t N>
> bool operator<= (const array<T,N>& x, const array<T,N>& y) {
> return !(y<x);
> }
> template<class T, std::size_t N>
> bool operator>= (const array<T,N>& x, const array<T,N>& y) {
> return !(x<y);
> }
>
>
> template<class T, std::size_t N>
> inline void swap (array<T,N>& x, array<T,N>& y) {
> x.swap(y);
> }
># 400 "/usr/include/boost/array.hpp" 3 4
> template <typename T, std::size_t N>
> T(&get_c_array(boost::array<T,N>& arg))[N]
> {
> return arg.elems;
> }
>
>
> template <typename T, std::size_t N>
> const T(&get_c_array(const boost::array<T,N>& arg))[N]
> {
> return arg.elems;
> }
># 433 "/usr/include/boost/array.hpp" 3 4
> template<class T, std::size_t N>
> std::size_t hash_value(const array<T,N>& arr)
> {
> return boost::hash_range(arr.begin(), arr.end());
> }
>
>}
># 20 "/usr/include/boost/multi_array/range_list.hpp" 2 3 4
>
>namespace boost {
>namespace detail {
>namespace multi_array {
>
>
>
>
>
>struct choose_range_list_n {
> template <typename T, std::size_t NumRanges>
> struct bind {
> typedef boost::array<T,NumRanges> type;
> };
>};
>
>struct choose_range_list_zero {
> template <typename T, std::size_t NumRanges>
> struct bind {
> typedef boost::array<T,1> type;
> };
>};
>
>
>template <std::size_t NumRanges>
>struct range_list_gen_helper {
> typedef choose_range_list_n choice;
>};
>
>template <>
>struct range_list_gen_helper<0> {
> typedef choose_range_list_zero choice;
>};
>
>template <typename T, std::size_t NumRanges>
>struct range_list_generator {
>private:
> typedef typename range_list_gen_helper<NumRanges>::choice Choice;
>public:
> typedef typename Choice::template bind<T,NumRanges>::type type;
>};
>
>
>
>
>
>}
>}
>}
># 18 "/usr/include/boost/multi_array/extent_gen.hpp" 2 3 4
># 1 "/usr/include/boost/multi_array/types.hpp" 1 3 4
># 21 "/usr/include/boost/multi_array/types.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 22 "/usr/include/boost/multi_array/types.hpp" 2 3 4
>
>namespace boost {
>namespace detail {
>namespace multi_array{
>
>
>typedef std::size_t size_type;
>typedef std::ptrdiff_t index;
>
>}
>}
>}
># 19 "/usr/include/boost/multi_array/extent_gen.hpp" 2 3 4
>
>
>
>namespace boost {
>namespace detail {
>namespace multi_array {
>
>
>template <std::size_t NumRanges>
>class extent_gen {
>public:
> typedef boost::detail::multi_array::index index;
> typedef boost::detail::multi_array::size_type size_type;
> typedef extent_range<index,size_type> range;
>private:
> typedef typename range_list_generator<range,NumRanges>::type range_list;
>public:
> template <std::size_t Ranges>
> struct gen_type {
> typedef extent_gen<Ranges> type;
> };
>
> range_list ranges_;
>
> extent_gen() { }
>
>
> extent_gen(const extent_gen<NumRanges-1>& rhs,
> const range& a_range)
> {
> std::copy(rhs.ranges_.begin(),rhs.ranges_.end(),ranges_.begin());
> *ranges_.rbegin() = a_range;
> }
>
> extent_gen<NumRanges+1>
> operator[](const range& a_range)
> {
> return extent_gen<NumRanges+1>(*this,a_range);
> }
>
> extent_gen<NumRanges+1>
> operator[](index idx)
> {
> return extent_gen<NumRanges+1>(*this,range(0,idx));
> }
>
> static extent_gen<0> extents() {
> return extent_gen<0>();
> }
>};
>
>}
>}
>}
># 23 "/usr/include/boost/multi_array/base.hpp" 2 3 4
># 1 "/usr/include/boost/multi_array/index_range.hpp" 1 3 4
># 28 "/usr/include/boost/multi_array/index_range.hpp" 3 4
>namespace boost {
>namespace detail {
>namespace multi_array {
>
> template <typename Index,typename SizeType>
> class index_range {
> public:
> typedef Index index;
> typedef SizeType size_type;
>
> private:
> static index from_start()
> { return (std::numeric_limits<index>::min)(); }
>
> static index to_end()
> { return (std::numeric_limits<index>::max)(); }
>
> public:
>
> index_range()
> {
> start_ = from_start();
> finish_ = to_end();
> stride_ = 1;
> degenerate_ = false;
> }
>
> explicit index_range(index pos)
> {
> start_ = pos;
> finish_ = pos+1;
> stride_ = 1;
> degenerate_ = true;
> }
>
> explicit index_range(index start, index finish, index stride=1)
> : start_(start), finish_(finish), stride_(stride),
> degenerate_(false)
> { }
>
>
>
> index_range& start(index s) {
> start_ = s;
> degenerate_ = false;
> return *this;
> }
>
> index_range& finish(index f) {
> finish_ = f;
> degenerate_ = false;
> return *this;
> }
>
> index_range& stride(index s) { stride_ = s; return *this; }
>
> index start() const
> {
> return start_;
> }
>
> index get_start(index low_index_range = index_range::from_start()) const
> {
> if (start_ == from_start())
> return low_index_range;
> return start_;
> }
>
> index finish() const
> {
> return finish_;
> }
>
> index get_finish(index high_index_range = index_range::to_end()) const
> {
> if (finish_ == to_end())
> return high_index_range;
> return finish_;
> }
>
> index stride() const { return stride_; }
>
> void set_index_range(index start, index finish, index stride=1)
> {
> start_ = start;
> finish_ = finish;
> stride_ = stride;
> }
>
> static index_range all()
> { return index_range(from_start(), to_end(), 1); }
>
> bool is_degenerate() const { return degenerate_; }
>
> index_range operator-(index shift) const
> {
> return index_range(start_ - shift, finish_ - shift, stride_);
> }
>
> index_range operator+(index shift) const
> {
> return index_range(start_ + shift, finish_ + shift, stride_);
> }
>
> index operator[](unsigned i) const
> {
> return start_ + i * stride_;
> }
>
> index operator()(unsigned i) const
> {
> return start_ + i * stride_;
> }
>
>
>
> public:
> index start_, finish_, stride_;
> bool degenerate_;
> };
>
>
>
>
>
> template <typename Index, typename SizeType>
> inline index_range<Index,SizeType>
> operator<=(Index s, const index_range<Index,SizeType>& r)
> {
> return index_range<Index,SizeType>(s, r.finish(), r.stride());
> }
>
>
> template <typename Index, typename SizeType>
> inline index_range<Index,SizeType>
> operator<(Index s, const index_range<Index,SizeType>& r)
> {
> return index_range<Index,SizeType>(s + 1, r.finish(), r.stride());
> }
>
>
> template <typename Index, typename SizeType>
> inline index_range<Index,SizeType>
> operator<(const index_range<Index,SizeType>& r, Index f)
> {
> return index_range<Index,SizeType>(r.start(), f, r.stride());
> }
>
>
> template <typename Index, typename SizeType>
> inline index_range<Index,SizeType>
> operator<=(const index_range<Index,SizeType>& r, Index f)
> {
> return index_range<Index,SizeType>(r.start(), f + 1, r.stride());
> }
>
>}
>}
>}
># 24 "/usr/include/boost/multi_array/base.hpp" 2 3 4
># 1 "/usr/include/boost/multi_array/index_gen.hpp" 1 3 4
># 21 "/usr/include/boost/multi_array/index_gen.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 22 "/usr/include/boost/multi_array/index_gen.hpp" 2 3 4
>
>namespace boost {
>namespace detail {
>namespace multi_array {
>
>
>template <int NumRanges, int NumDims>
>struct index_gen {
>private:
> typedef ::boost::detail::multi_array::index index;
> typedef ::boost::detail::multi_array::size_type size_type;
> typedef index_range<index,size_type> range;
>public:
> template <int Dims, int Ranges>
> struct gen_type {
> typedef index_gen<Ranges,Dims> type;
> };
>
> typedef typename range_list_generator<range,NumRanges>::type range_list;
> range_list ranges_;
>
> index_gen() { }
>
> template <int ND>
> explicit index_gen(const index_gen<NumRanges-1,ND>& rhs,
> const range& r)
> {
> std::copy(rhs.ranges_.begin(),rhs.ranges_.end(),ranges_.begin());
> *ranges_.rbegin() = r;
> }
>
> index_gen<NumRanges+1,NumDims+1>
> operator[](const range& r) const
> {
> index_gen<NumRanges+1,NumDims+1> tmp;
> std::copy(ranges_.begin(),ranges_.end(),tmp.ranges_.begin());
> *tmp.ranges_.rbegin() = r;
> return tmp;
> }
>
> index_gen<NumRanges+1,NumDims>
> operator[](index idx) const
> {
> index_gen<NumRanges+1,NumDims> tmp;
> std::copy(ranges_.begin(),ranges_.end(),tmp.ranges_.begin());
> *tmp.ranges_.rbegin() = range(idx);
> return tmp;
> }
>
> static index_gen<0,0> indices() {
> return index_gen<0,0>();
> }
>};
>
>}
>}
>}
># 25 "/usr/include/boost/multi_array/base.hpp" 2 3 4
># 1 "/usr/include/boost/multi_array/storage_order.hpp" 1 3 4
># 18 "/usr/include/boost/multi_array/storage_order.hpp" 3 4
># 1 "/usr/include/boost/multi_array/algorithm.hpp" 1 3 4
># 45 "/usr/include/boost/multi_array/algorithm.hpp" 3 4
>namespace boost {
>namespace detail {
>namespace multi_array {
>
>
>
>
>template <class InputIter, class Size, class OutputIter>
>OutputIter copy_n(InputIter first, Size count,
> OutputIter result) {
> for ( ; count > 0; --count) {
> *result = *first;
> ++first;
> ++result;
> }
> return result;
>}
># 99 "/usr/include/boost/multi_array/algorithm.hpp" 3 4
>}
>}
>}
># 19 "/usr/include/boost/multi_array/storage_order.hpp" 2 3 4
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 21 "/usr/include/boost/multi_array/storage_order.hpp" 2 3 4
>
>
>
>
>namespace boost {
>
>
> class c_storage_order;
> class fortran_storage_order;
>
> template <std::size_t NumDims>
> class general_storage_order
> {
> public:
> typedef detail::multi_array::size_type size_type;
> template <typename OrderingIter, typename AscendingIter>
> general_storage_order(OrderingIter ordering,
> AscendingIter ascending) {
> boost::detail::multi_array::copy_n(ordering,NumDims,ordering_.begin());
> boost::detail::multi_array::copy_n(ascending,NumDims,ascending_.begin());
> }
>
>
>
>
>
> general_storage_order(const c_storage_order&) {
> for (size_type i=0; i != NumDims; ++i) {
> ordering_[i] = NumDims - 1 - i;
> }
> ascending_.assign(true);
> }
>
> general_storage_order(const fortran_storage_order&) {
> for (size_type i=0; i != NumDims; ++i) {
> ordering_[i] = i;
> }
> ascending_.assign(true);
> }
>
> size_type ordering(size_type dim) const { return ordering_[dim]; }
> bool ascending(size_type dim) const { return ascending_[dim]; }
>
> bool all_dims_ascending() const {
> return std::accumulate(ascending_.begin(),ascending_.end(),true,
> std::logical_and<bool>());
> }
>
> bool operator==(general_storage_order const& rhs) const {
> return (ordering_ == rhs.ordering_) &&
> (ascending_ == rhs.ascending_);
> }
>
> protected:
> boost::array<size_type,NumDims> ordering_;
> boost::array<bool,NumDims> ascending_;
> };
>
> class c_storage_order
> {
> typedef detail::multi_array::size_type size_type;
> public:
>
>
>
> template <std::size_t NumDims>
> operator general_storage_order<NumDims>() const {
> boost::array<size_type,NumDims> ordering;
> boost::array<bool,NumDims> ascending;
>
> for (size_type i=0; i != NumDims; ++i) {
> ordering[i] = NumDims - 1 - i;
> ascending[i] = true;
> }
> return general_storage_order<NumDims>(ordering.begin(),
> ascending.begin());
> }
>
> };
>
> class fortran_storage_order
> {
> typedef detail::multi_array::size_type size_type;
> public:
>
>
>
> template <std::size_t NumDims>
> operator general_storage_order<NumDims>() const {
> boost::array<size_type,NumDims> ordering;
> boost::array<bool,NumDims> ascending;
>
> for (size_type i=0; i != NumDims; ++i) {
> ordering[i] = i;
> ascending[i] = true;
> }
> return general_storage_order<NumDims>(ordering.begin(),
> ascending.begin());
> }
>
> };
>
>}
># 26 "/usr/include/boost/multi_array/base.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/multi_array/concept_checks.hpp" 1 3 4
># 22 "/usr/include/boost/multi_array/concept_checks.hpp" 3 4
># 1 "/usr/include/boost/iterator/iterator_concepts.hpp" 1 3 4
># 31 "/usr/include/boost/iterator/iterator_concepts.hpp" 3 4
># 1 "/usr/include/boost/concept/detail/concept_def.hpp" 1 3 4
># 32 "/usr/include/boost/iterator/iterator_concepts.hpp" 2 3 4
>
>namespace boost_concepts
>{
>
>
>
>
>
>
>
> template < typename Iterator > struct ReadableIterator; template < typename Iterator > struct ReadableIteratorConcept : ReadableIterator< Iterator > { }; template < typename Iterator > struct ReadableIterator
> : boost::Assignable<Iterator>
> , boost::CopyConstructible<Iterator>
>
> {
> typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
> typedef typename boost::detail::iterator_traits<Iterator>::reference reference;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ReadableIterator>)>::failed> boost_concept_check50 __attribute__((unused)); ~ReadableIterator()
> {
>
> value_type v = *i;
> boost::ignore_unused_variable_warning(v);
> }
> private:
> Iterator i;
> };
>
> template <
> typename Iterator
> , typename ValueType = typename boost::detail::iterator_traits<Iterator>::value_type
> >
> struct WritableIterator
> : boost::CopyConstructible<Iterator>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<WritableIterator>)>::failed> boost_concept_check67 __attribute__((unused)); ~WritableIterator()
> {
> *i = v;
> }
> private:
> ValueType v;
> Iterator i;
> };
>
> template <
> typename Iterator
> , typename ValueType = typename boost::detail::iterator_traits<Iterator>::value_type
> >
> struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};
>
> template < typename Iterator > struct SwappableIterator; template < typename Iterator > struct SwappableIteratorConcept : SwappableIterator< Iterator > { }; template < typename Iterator > struct SwappableIterator
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SwappableIterator>)>::failed> boost_concept_check84 __attribute__((unused)); ~SwappableIterator()
> {
> std::iter_swap(i1, i2);
> }
> private:
> Iterator i1;
> Iterator i2;
> };
>
> template < typename Iterator > struct LvalueIterator; template < typename Iterator > struct LvalueIteratorConcept : LvalueIterator< Iterator > { }; template < typename Iterator > struct LvalueIterator
> {
> typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<LvalueIterator>)>::failed> boost_concept_check97 __attribute__((unused)); ~LvalueIterator()
> {
> value_type& r = const_cast<value_type&>(*i);
> boost::ignore_unused_variable_warning(r);
> }
> private:
> Iterator i;
> };
>
>
>
>
>
> template < typename Iterator > struct IncrementableIterator; template < typename Iterator > struct IncrementableIteratorConcept : IncrementableIterator< Iterator > { }; template < typename Iterator > struct IncrementableIterator
> : boost::Assignable<Iterator>
> , boost::CopyConstructible<Iterator>
> {
> typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( boost::Convertible< traversal_category , boost::incrementable_traversal_tag >)>::failed> boost_concept_check120 __attribute__((unused))
>
>
>
> ;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<IncrementableIterator>)>::failed> boost_concept_check122 __attribute__((unused)); ~IncrementableIterator()
> {
> ++i;
> (void)i++;
> }
> private:
> Iterator i;
> };
>
> template < typename Iterator > struct SinglePassIterator; template < typename Iterator > struct SinglePassIteratorConcept : SinglePassIterator< Iterator > { }; template < typename Iterator > struct SinglePassIterator
> : IncrementableIterator<Iterator>
> , boost::EqualityComparable<Iterator>
>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( boost::Convertible< typename SinglePassIterator::traversal_category , boost::single_pass_traversal_tag > )>::failed> boost_concept_check140 __attribute__((unused))
>
>
>
> ;
> };
>
> template < typename Iterator > struct ForwardTraversal; template < typename Iterator > struct ForwardTraversalConcept : ForwardTraversal< Iterator > { }; template < typename Iterator > struct ForwardTraversal
> : SinglePassIterator<Iterator>
> , boost::DefaultConstructible<Iterator>
> {
> typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
>
> enum { mpl_assertion_in_line_149 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (boost::is_integral<difference_type>))0, 1 ) ) ) };
> enum { mpl_assert_rel_value150 = (std::numeric_limits<difference_type>::is_signed == true) }; enum { mpl_assertion_in_line_150 = sizeof( boost::mpl::assertion_failed<mpl_assert_rel_value150>( (boost::mpl::failed ************ ( boost::mpl::assert_relation< boost::mpl::assert_::relations( sizeof( boost::mpl::assert_::arg == boost::mpl::assert_::arg ) ) , std::numeric_limits<difference_type>::is_signed , true >::************)) 0 ) ) };
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( boost::Convertible< typename ForwardTraversal::traversal_category , boost::forward_traversal_tag > )>::failed> boost_concept_check156 __attribute__((unused))
>
>
>
> ;
> };
>
> template < typename Iterator > struct BidirectionalTraversal; template < typename Iterator > struct BidirectionalTraversalConcept : BidirectionalTraversal< Iterator > { }; template < typename Iterator > struct BidirectionalTraversal
> : ForwardTraversal<Iterator>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( boost::Convertible< typename BidirectionalTraversal::traversal_category , boost::bidirectional_traversal_tag > )>::failed> boost_concept_check166 __attribute__((unused))
>
>
>
> ;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BidirectionalTraversal>)>::failed> boost_concept_check168 __attribute__((unused)); ~BidirectionalTraversal()
> {
> --i;
> (void)i--;
> }
> private:
> Iterator i;
> };
>
> template < typename Iterator > struct RandomAccessTraversal; template < typename Iterator > struct RandomAccessTraversalConcept : RandomAccessTraversal< Iterator > { }; template < typename Iterator > struct RandomAccessTraversal
> : BidirectionalTraversal<Iterator>
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( boost::Convertible< typename RandomAccessTraversal::traversal_category , boost::random_access_traversal_tag > )>::failed> boost_concept_check184 __attribute__((unused))
>
>
>
> ;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<RandomAccessTraversal>)>::failed> boost_concept_check186 __attribute__((unused)); ~RandomAccessTraversal()
> {
> i += n;
> i = i + n;
> i = n + i;
> i -= n;
> i = i - n;
> n = i - j;
> }
>
> private:
> typename BidirectionalTraversal<Iterator>::difference_type n;
> Iterator i, j;
> };
>
>
>
>
> namespace detail
> {
> template <typename Iterator1, typename Iterator2>
> void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2)
> {
> bool b;
> b = i1 == i2;
> b = i1 != i2;
>
> b = i2 == i1;
> b = i2 != i1;
> boost::ignore_unused_variable_warning(b);
> }
>
> template <typename Iterator1, typename Iterator2>
> void interop_rand_access_constraints(
> Iterator1 const& i1, Iterator2 const& i2,
> boost::random_access_traversal_tag, boost::random_access_traversal_tag)
> {
> bool b;
> typename boost::detail::iterator_traits<Iterator2>::difference_type n;
> b = i1 < i2;
> b = i1 <= i2;
> b = i1 > i2;
> b = i1 >= i2;
> n = i1 - i2;
>
> b = i2 < i1;
> b = i2 <= i1;
> b = i2 > i1;
> b = i2 >= i1;
> n = i2 - i1;
> boost::ignore_unused_variable_warning(b);
> boost::ignore_unused_variable_warning(n);
> }
>
> template <typename Iterator1, typename Iterator2>
> void interop_rand_access_constraints(
> Iterator1 const&, Iterator2 const&,
> boost::single_pass_traversal_tag, boost::single_pass_traversal_tag)
> { }
>
> }
>
> template < typename Iterator , typename ConstIterator > struct InteroperableIterator; template < typename Iterator , typename ConstIterator > struct InteroperableIteratorConcept : InteroperableIterator< Iterator, ConstIterator > { }; template < typename Iterator , typename ConstIterator > struct InteroperableIterator
> {
> private:
> typedef typename boost::detail::pure_traversal_tag<
> typename boost::iterator_traversal<
> Iterator
> >::type
> >::type traversal_category;
>
> typedef typename boost::detail::pure_traversal_tag<
> typename boost::iterator_traversal<
> ConstIterator
> >::type
> >::type const_traversal_category;
>
> public:
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(SinglePassIterator<Iterator>)>::failed> boost_concept_check264 __attribute__((unused));
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(SinglePassIterator<ConstIterator>)>::failed> boost_concept_check265 __attribute__((unused));
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<InteroperableIterator>)>::failed> boost_concept_check267 __attribute__((unused)); ~InteroperableIterator()
> {
> detail::interop_single_pass_constraints(i, ci);
> detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category());
>
> ci = i;
> }
>
> private:
> Iterator i;
> ConstIterator ci;
> };
>
>}
>
># 1 "/usr/include/boost/concept/detail/concept_undef.hpp" 1 3 4
># 283 "/usr/include/boost/iterator/iterator_concepts.hpp" 2 3 4
># 23 "/usr/include/boost/multi_array/concept_checks.hpp" 2 3 4
>
>namespace boost {
>namespace multi_array_concepts {
>
>namespace detail {
># 37 "/usr/include/boost/multi_array/concept_checks.hpp" 3 4
> template <std::size_t N>
> struct idgen_helper {
>
> template <typename Array, typename IdxGen, typename Call_Type>
> static void call(Array& a, const IdxGen& idgen, Call_Type c) {
> typedef typename Array::index_range index_range;
> typedef typename Array::index index;
> idgen_helper<N-1>::call(a,idgen[c],c);
> }
> };
>
> template <>
> struct idgen_helper<0> {
>
> template <typename Array, typename IdxGen, typename Call_Type>
> static void call(Array& a, const IdxGen& idgen, Call_Type) {
> typedef typename Array::index_range index_range;
> typedef typename Array::index index;
> a[ idgen ];
> }
> };
>
>}
>
>
> template <typename Array, std::size_t NumDims >
> struct ConstMultiArrayConcept
> {
> void constraints() {
>
> function_requires< boost_concepts::ForwardTraversalConcept<iterator> >();
> function_requires< boost_concepts::ReadableIteratorConcept<iterator> >();
> function_requires< boost_concepts::ForwardTraversalConcept<const_iterator> >();
> function_requires< boost_concepts::ReadableIteratorConcept<const_iterator> >();
>
>
> a[ id ];
>
> detail::idgen_helper<NumDims-1>::call(a,idgen[range],id);
>
>
> detail::idgen_helper<NumDims-1>::call(a,idgen[range],range);
>
> st = a.size();
> st = a.num_dimensions();
> st = Array::dimensionality;
> st = a.num_elements();
> stp = a.shape();
> idp = a.strides();
> idp = a.index_bases();
> cit = a.begin();
> cit = a.end();
> crit = a.rbegin();
> crit = a.rend();
> eltp = a.origin();
> }
>
> typedef typename Array::value_type value_type;
> typedef typename Array::reference reference;
> typedef typename Array::const_reference const_reference;
> typedef typename Array::size_type size_type;
> typedef typename Array::difference_type difference_type;
> typedef typename Array::iterator iterator;
> typedef typename Array::const_iterator const_iterator;
> typedef typename Array::reverse_iterator reverse_iterator;
> typedef typename Array::const_reverse_iterator const_reverse_iterator;
> typedef typename Array::element element;
> typedef typename Array::index index;
> typedef typename Array::index_gen index_gen;
> typedef typename Array::index_range index_range;
> typedef typename Array::extent_gen extent_gen;
> typedef typename Array::extent_range extent_range;
>
> Array a;
> size_type st;
> const size_type* stp;
> index id;
> const index* idp;
> const_iterator cit;
> const_reverse_iterator crit;
> const element* eltp;
> index_gen idgen;
> index_range range;
> };
>
>
> template <typename Array, std::size_t NumDims >
> struct MutableMultiArrayConcept
> {
> void constraints() {
>
>
> function_requires< boost_concepts::ForwardTraversalConcept<iterator> >();
> function_requires< boost_concepts::ReadableIteratorConcept<iterator> >();
> function_requires< boost_concepts::WritableIteratorConcept<iterator> >();
> function_requires< boost_concepts::ForwardTraversalConcept<const_iterator> >();
> function_requires< boost_concepts::ReadableIteratorConcept<const_iterator> >();
> function_requires< boost::OutputIterator<iterator,value_type> >();
>
>
> value_type vt = a[ id ];
>
>
> detail::idgen_helper<NumDims-1>::call(a,idgen[range],id);
>
>
> detail::idgen_helper<NumDims-1>::call(a,idgen[range],range);
>
> st = a.size();
> st = a.num_dimensions();
> st = a.num_elements();
> stp = a.shape();
> idp = a.strides();
> idp = a.index_bases();
> it = a.begin();
> it = a.end();
> rit = a.rbegin();
> rit = a.rend();
> eltp = a.origin();
> const_constraints(a);
> }
>
> void const_constraints(const Array& a) {
>
>
>
>
> detail::idgen_helper<NumDims-1>::call(a,idgen[range],id);
>
>
> detail::idgen_helper<NumDims-1>::call(a,idgen[range],range);
>
> st = a.size();
> st = a.num_dimensions();
> st = a.num_elements();
> stp = a.shape();
> idp = a.strides();
> idp = a.index_bases();
> cit = a.begin();
> cit = a.end();
> crit = a.rbegin();
> crit = a.rend();
> eltp = a.origin();
> }
>
> typedef typename Array::value_type value_type;
> typedef typename Array::reference reference;
> typedef typename Array::const_reference const_reference;
> typedef typename Array::size_type size_type;
> typedef typename Array::difference_type difference_type;
> typedef typename Array::iterator iterator;
> typedef typename Array::const_iterator const_iterator;
> typedef typename Array::reverse_iterator reverse_iterator;
> typedef typename Array::const_reverse_iterator const_reverse_iterator;
> typedef typename Array::element element;
> typedef typename Array::index index;
> typedef typename Array::index_gen index_gen;
> typedef typename Array::index_range index_range;
> typedef typename Array::extent_gen extent_gen;
> typedef typename Array::extent_range extent_range;
>
> Array a;
> size_type st;
> const size_type* stp;
> index id;
> const index* idp;
> iterator it;
> const_iterator cit;
> reverse_iterator rit;
> const_reverse_iterator crit;
> const element* eltp;
> index_gen idgen;
> index_range range;
> };
>
>
>}
>
>namespace detail {
> namespace multi_array {
> using boost::multi_array_concepts::ConstMultiArrayConcept;
> using boost::multi_array_concepts::MutableMultiArrayConcept;
> }
>}
>
>}
># 29 "/usr/include/boost/multi_array/base.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/size_t.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/size_t.hpp" 3 4
># 1 "/usr/include/boost/mpl/size_t_fwd.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/size_t_fwd.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/mpl/size_t_fwd.hpp" 2 3 4
>
>namespace mpl_ {
>
>template< std::size_t N > struct size_t;
>
>}
>namespace boost { namespace mpl { using ::mpl_::size_t; } }
># 18 "/usr/include/boost/mpl/size_t.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
># 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
>namespace mpl_ {
>
>template< std::size_t N >
>struct size_t
>{
> static const std::size_t value = N;
>
>
>
>
>
> typedef size_t type;
>
> typedef std::size_t value_type;
> typedef integral_c_tag tag;
># 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
> typedef mpl_::size_t< static_cast<std::size_t>((value + 1)) > next;
> typedef mpl_::size_t< static_cast<std::size_t>((value - 1)) > prior;
>
>
>
>
>
>
> operator std::size_t() const { return static_cast<std::size_t>(this->value); }
>};
>
>
>template< std::size_t N >
>std::size_t const mpl_::size_t< N >::value;
>
>
>}
># 24 "/usr/include/boost/mpl/size_t.hpp" 2 3 4
># 32 "/usr/include/boost/multi_array/base.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/msvc_eti_base.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/msvc_eti_base.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
># 62 "/usr/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 3 4
>}}}
># 18 "/usr/include/boost/mpl/aux_/msvc_eti_base.hpp" 2 3 4
>
>
>
>
>namespace boost { namespace mpl { namespace aux {
># 55 "/usr/include/boost/mpl/aux_/msvc_eti_base.hpp" 3 4
>template< typename T > struct msvc_eti_base
> : T
>{
>
> msvc_eti_base();
>
> typedef T type;
>};
>
>
>
>template<> struct msvc_eti_base<int>
>{
> typedef msvc_eti_base type;
> typedef msvc_eti_base first;
> typedef msvc_eti_base second;
> typedef msvc_eti_base tag;
> enum { value = 0 };
>};
>
>}}}
># 33 "/usr/include/boost/multi_array/base.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/type.hpp" 1 3 4
># 9 "/usr/include/boost/type.hpp" 3 4
>namespace boost {
>
>
>
> template <class T>
> struct type {};
>
>}
># 36 "/usr/include/boost/multi_array/base.hpp" 2 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 37 "/usr/include/boost/multi_array/base.hpp" 2 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 38 "/usr/include/boost/multi_array/base.hpp" 2 3 4
>
>
>namespace boost {
>
>
>
>
>
>template<typename T, std::size_t NumDims,
> typename Allocator = std::allocator<T> >
>class multi_array;
>
>
>namespace multi_array_types {
> typedef boost::detail::multi_array::size_type size_type;
> typedef std::ptrdiff_t difference_type;
> typedef boost::detail::multi_array::index index;
> typedef detail::multi_array::index_range<index,size_type> index_range;
> typedef detail::multi_array::extent_range<index,size_type> extent_range;
> typedef detail::multi_array::index_gen<0,0> index_gen;
> typedef detail::multi_array::extent_gen<0> extent_gen;
>}
># 69 "/usr/include/boost/multi_array/base.hpp" 3 4
>namespace {
> multi_array_types::extent_gen extents;
> multi_array_types::index_gen indices;
>}
>
>
>namespace detail {
>namespace multi_array {
>
>template <typename T, std::size_t NumDims>
>class sub_array;
>
>template <typename T, std::size_t NumDims, typename TPtr = const T*>
>class const_sub_array;
>
> template <typename T, typename TPtr, typename NumDims, typename Reference,
> typename IteratorCategory>
>class array_iterator;
>
>template <typename T, std::size_t NumDims, typename TPtr = const T*>
>class const_multi_array_view;
>
>template <typename T, std::size_t NumDims>
>class multi_array_view;
>
>
>
>
>
>class multi_array_base {
>public:
> typedef multi_array_types::size_type size_type;
> typedef multi_array_types::difference_type difference_type;
> typedef multi_array_types::index index;
> typedef multi_array_types::index_range index_range;
> typedef multi_array_types::extent_range extent_range;
> typedef multi_array_types::index_gen index_gen;
> typedef multi_array_types::extent_gen extent_gen;
>};
>
>
>
>
>
>
>template<typename T, std::size_t NumDims>
>class value_accessor_n : public multi_array_base {
> typedef multi_array_base super_type;
>public:
> typedef typename super_type::index index;
>
>
>
>
> typedef T element;
> typedef boost::multi_array<T,NumDims-1> value_type;
> typedef sub_array<T,NumDims-1> reference;
> typedef const_sub_array<T,NumDims-1> const_reference;
>
>protected:
>
> template <typename Reference, typename TPtr>
> Reference access(boost::type<Reference>,index idx,TPtr base,
> const size_type* extents,
> const index* strides,
> const index* index_bases) const {
>
> ((void)0);
> ((void)0);
>
> TPtr newbase = base + idx * strides[0];
> return Reference(newbase,extents+1,strides+1,index_bases+1);
>
> }
>
> value_accessor_n() { }
> ~value_accessor_n() { }
>};
># 155 "/usr/include/boost/multi_array/base.hpp" 3 4
>template<typename T>
>class value_accessor_one : public multi_array_base {
> typedef multi_array_base super_type;
>public:
> typedef typename super_type::index index;
>
>
>
> typedef T element;
> typedef T value_type;
> typedef T& reference;
> typedef T const& const_reference;
>
>protected:
>
> template <typename Reference, typename TPtr>
> Reference access(boost::type<Reference>,index idx,TPtr base,
> const size_type* extents,
> const index* strides,
> const index* index_bases) const {
>
> ignore_unused_variable_warning(index_bases);
> ignore_unused_variable_warning(extents);
> ((void)0);
> ((void)0);
> return *(base + idx * strides[0]);
> }
>
> value_accessor_one() { }
> ~value_accessor_one() { }
>};
>
>
>
>
>
>
>template <typename T, std::size_t NumDims>
>struct choose_value_accessor_n {
> typedef value_accessor_n<T,NumDims> type;
>};
>
>template <typename T>
>struct choose_value_accessor_one {
> typedef value_accessor_one<T> type;
>};
>
>template <typename T, typename NumDims>
>struct value_accessor_generator {
> static const std::size_t dimensionality = NumDims::value;
>
> typedef typename
> mpl::eval_if_c<(dimensionality == 1),
> choose_value_accessor_one<T>,
> choose_value_accessor_n<T,dimensionality>
> >::type type;
>};
># 244 "/usr/include/boost/multi_array/base.hpp" 3 4
>template <class T, class NumDims>
>struct associated_types
> : value_accessor_generator<T,NumDims>::type
>{};
># 272 "/usr/include/boost/multi_array/base.hpp" 3 4
>template <typename T, std::size_t NumDims>
>class multi_array_impl_base
> :
>
>
>
>
>
> public value_accessor_generator<T,mpl::size_t<NumDims> >::type
>
>{
> typedef associated_types<T,mpl::size_t<NumDims> > types;
>public:
> typedef typename types::index index;
> typedef typename types::size_type size_type;
> typedef typename types::element element;
> typedef typename types::index_range index_range;
> typedef typename types::value_type value_type;
> typedef typename types::reference reference;
> typedef typename types::const_reference const_reference;
>
> template <std::size_t NDims>
> struct subarray {
> typedef boost::detail::multi_array::sub_array<T,NDims> type;
> };
>
> template <std::size_t NDims>
> struct const_subarray {
> typedef boost::detail::multi_array::const_sub_array<T,NDims> type;
> };
>
> template <std::size_t NDims>
> struct array_view {
> typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
> };
>
> template <std::size_t NDims>
> struct const_array_view {
> public:
> typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
> };
># 322 "/usr/include/boost/multi_array/base.hpp" 3 4
> typedef array_iterator<T,T*,mpl::size_t<NumDims>,reference,
> boost::random_access_traversal_tag> iterator;
>
> typedef array_iterator<T,T const*,mpl::size_t<NumDims>,const_reference,
> boost::random_access_traversal_tag> const_iterator;
>
> typedef ::boost::reverse_iterator<iterator> reverse_iterator;
> typedef ::boost::reverse_iterator<const_iterator> const_reverse_iterator;
>
> static const std::size_t dimensionality = NumDims;
>protected:
>
> multi_array_impl_base() { }
> ~multi_array_impl_base() { }
>
>
> template <typename Reference, typename IndexList, typename TPtr>
> Reference access_element(boost::type<Reference>,
> const IndexList& indices,
> TPtr base,
> const size_type* extents,
> const index* strides,
> const index* index_bases) const {
> boost::function_requires<
> CollectionConcept<IndexList> >();
> ignore_unused_variable_warning(index_bases);
> ignore_unused_variable_warning(extents);
>
>
>
>
>
>
>
> index offset = 0;
> {
> typename IndexList::const_iterator i = indices.begin();
> size_type n = 0;
> while (n != NumDims) {
> offset += (*i) * strides[n];
> ++n;
> ++i;
> }
> }
> return base[offset];
> }
>
> template <typename StrideList, typename ExtentList>
> void compute_strides(StrideList& stride_list, ExtentList& extent_list,
> const general_storage_order<NumDims>& storage)
> {
>
> index stride = 1;
> for (size_type n = 0; n != NumDims; ++n) {
> index stride_sign = +1;
>
> if (!storage.ascending(storage.ordering(n)))
> stride_sign = -1;
>
>
>
> stride_list[storage.ordering(n)] = stride * stride_sign;
>
> stride *= extent_list[storage.ordering(n)];
> }
> }
>
>
>
>
> template <typename StrideList, typename ExtentList, typename BaseList>
> index
> calculate_origin_offset(const StrideList& stride_list,
> const ExtentList& extent_list,
> const general_storage_order<NumDims>& storage,
> const BaseList& index_base_list)
> {
> return
> calculate_descending_dimension_offset(stride_list,extent_list,
> storage) +
> calculate_indexing_offset(stride_list,index_base_list);
> }
>
>
>
> template <typename StrideList, typename ExtentList>
> index
> calculate_descending_dimension_offset(const StrideList& stride_list,
> const ExtentList& extent_list,
> const general_storage_order<NumDims>& storage)
> {
> index offset = 0;
> if (!storage.all_dims_ascending())
> for (size_type n = 0; n != NumDims; ++n)
> if (!storage.ascending(n))
> offset -= (extent_list[n] - 1) * stride_list[n];
>
> return offset;
> }
>
>
>
>
>
> template <typename StrideList, typename BaseList>
> index
> calculate_indexing_offset(const StrideList& stride_list,
> const BaseList& index_base_list)
> {
> index offset = 0;
> for (size_type n = 0; n != NumDims; ++n)
> offset -= stride_list[n] * index_base_list[n];
> return offset;
> }
># 446 "/usr/include/boost/multi_array/base.hpp" 3 4
> template <typename ArrayRef, int NDims, typename TPtr>
> ArrayRef
> generate_array_view(boost::type<ArrayRef>,
> const boost::detail::multi_array::
> index_gen<NumDims,NDims>& indices,
> const size_type* extents,
> const index* strides,
> const index* index_bases,
> TPtr base) const {
>
> boost::array<index,NDims> new_strides;
> boost::array<index,NDims> new_extents;
>
> index offset = 0;
> size_type dim = 0;
> for (size_type n = 0; n != NumDims; ++n) {
>
>
> const index default_start = index_bases[n];
> const index default_finish = default_start+extents[n];
> const index_range& current_range = indices.ranges_[n];
> index start = current_range.get_start(default_start);
> index finish = current_range.get_finish(default_finish);
> index stride = current_range.stride();
> ((void)0);
># 480 "/usr/include/boost/multi_array/base.hpp" 3 4
> index len;
> if ((finish - start) / stride < 0) {
>
>
> len = 0;
> } else {
>
>
> index shrinkage = stride > 0 ? 1 : -1;
> len = (finish - start + (stride - shrinkage)) / stride;
> }
>
>
>
>
> ((void)0)
>
> ;
># 511 "/usr/include/boost/multi_array/base.hpp" 3 4
> offset += start * strides[n];
>
> if (!current_range.is_degenerate()) {
>
>
>
> new_strides[dim] = stride * strides[n];
>
>
> new_extents[dim] = len;
> ++dim;
> }
> }
> ((void)0);
>
> return
> ArrayRef(base+offset,
> new_extents,
> new_strides);
> }
>
>
>};
>
>}
>}
>
>}
># 22 "/usr/include/boost/multi_array.hpp" 2 3 4
># 1 "/usr/include/boost/multi_array/collection_concept.hpp" 1 3 4
># 18 "/usr/include/boost/multi_array/collection_concept.hpp" 3 4
>namespace boost {
>namespace detail {
>namespace multi_array {
> using boost::CollectionConcept;
>}
>}
>
>}
># 23 "/usr/include/boost/multi_array.hpp" 2 3 4
># 1 "/usr/include/boost/multi_array/copy_array.hpp" 1 3 4
># 22 "/usr/include/boost/multi_array/copy_array.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 23 "/usr/include/boost/multi_array/copy_array.hpp" 2 3 4
>
>namespace boost {
>namespace detail {
>namespace multi_array {
>
>template <typename Element>
>class copy_dispatch {
>public:
> template <typename SourceIterator, typename DestIterator>
> static void copy_array (SourceIterator first, SourceIterator last,
> DestIterator result) {
> while (first != last) {
> copy_array(*first++,*result++);
> }
> }
>private:
>
>
> template <typename Array1, typename Array2>
> static void copy_array (const Array1& source, Array2 dest) {
> copy_array(source.begin(),source.end(),dest.begin());
> }
>
> static void copy_array (const Element& source, Element& dest) {
> dest = source;
> }
>
>};
>
>
>template <typename Array1, typename Array2>
>void copy_array (Array1& source, Array2& dest) {
> ((void)0)
> ;
>
> typedef typename Array1::element element_type;
> copy_dispatch<element_type>::
> copy_array(source.begin(),source.end(),dest.begin());
>}
>
>
>}
>}
>}
># 24 "/usr/include/boost/multi_array.hpp" 2 3 4
># 1 "/usr/include/boost/multi_array/iterator.hpp" 1 3 4
># 25 "/usr/include/boost/multi_array/iterator.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 26 "/usr/include/boost/multi_array/iterator.hpp" 2 3 4
>
>
>namespace boost {
>namespace detail {
>namespace multi_array {
>
>
>
>
>
>template <class T>
>struct operator_arrow_proxy
>{
> operator_arrow_proxy(T const& px) : value_(px) {}
> T* operator->() const { return &value_; }
>
>
> operator T*() const { return &value_; }
> mutable T value_;
>};
>
>template <typename T, typename TPtr, typename NumDims, typename Reference,
> typename IteratorCategory>
>class array_iterator;
>
>template <typename T, typename TPtr, typename NumDims, typename Reference,
> typename IteratorCategory>
>class array_iterator
> : public
> iterator_facade<
> array_iterator<T,TPtr,NumDims,Reference,IteratorCategory>
> , typename associated_types<T,NumDims>::value_type
> , IteratorCategory
> , Reference
> >
> , private
>
>
>
> value_accessor_generator<T,NumDims>::type
>
>
>
>{
> friend class iterator_core_access;
> typedef detail::multi_array::associated_types<T,NumDims> access_t;
>
> typedef iterator_facade<
> array_iterator<T,TPtr,NumDims,Reference,IteratorCategory>
> , typename detail::multi_array::associated_types<T,NumDims>::value_type
> , boost::random_access_traversal_tag
> , Reference
> > facade_type;
>
> typedef typename access_t::index index;
> typedef typename access_t::size_type size_type;
>
>
> template <typename, typename, typename, typename, typename>
> friend class array_iterator;
>
>
>
>
> index idx_;
> TPtr base_;
> const size_type* extents_;
> const index* strides_;
> const index* index_base_;
>
>public:
>
> typedef typename facade_type::reference reference;
> typedef typename facade_type::value_type value_type;
> typedef typename facade_type::difference_type difference_type;
>
> array_iterator() {}
>
> array_iterator(index idx, TPtr base, const size_type* extents,
> const index* strides,
> const index* index_base) :
> idx_(idx), base_(base), extents_(extents),
> strides_(strides), index_base_(index_base) { }
>
> template <typename OPtr, typename ORef, typename Cat>
> array_iterator(
> const array_iterator<T,OPtr,NumDims,ORef,Cat>& rhs
> , typename boost::enable_if_convertible<OPtr,TPtr>::type* = 0
> )
> : idx_(rhs.idx_), base_(rhs.base_), extents_(rhs.extents_),
> strides_(rhs.strides_), index_base_(rhs.index_base_) { }
>
>
>
> operator_arrow_proxy<reference>
> operator->() const
> {
> return operator_arrow_proxy<reference>(this->dereference());
> }
>
>
> reference dereference() const
> {
> typedef typename value_accessor_generator<T,NumDims>::type accessor;
> return accessor::access(boost::type<reference>(),
> idx_,
> base_,
> extents_,
> strides_,
> index_base_);
> }
>
> void increment() { ++idx_; }
> void decrement() { --idx_; }
>
> template <class IteratorAdaptor>
> bool equal(IteratorAdaptor& rhs) const {
> const std::size_t N = NumDims::value;
> return (idx_ == rhs.idx_) &&
> (base_ == rhs.base_) &&
> ( (extents_ == rhs.extents_) ||
> std::equal(extents_,extents_+N,rhs.extents_) ) &&
> ( (strides_ == rhs.strides_) ||
> std::equal(strides_,strides_+N,rhs.strides_) ) &&
> ( (index_base_ == rhs.index_base_) ||
> std::equal(index_base_,index_base_+N,rhs.index_base_) );
> }
>
> template <class DifferenceType>
> void advance(DifferenceType n) {
> idx_ += n;
> }
>
> template <class IteratorAdaptor>
> typename facade_type::difference_type
> distance_to(IteratorAdaptor& rhs) const {
> return rhs.idx_ - idx_;
> }
>
>
>};
>
>}
>}
>}
># 25 "/usr/include/boost/multi_array.hpp" 2 3 4
># 1 "/usr/include/boost/multi_array/subarray.hpp" 1 3 4
># 26 "/usr/include/boost/multi_array/subarray.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 27 "/usr/include/boost/multi_array/subarray.hpp" 2 3 4
>
>
>namespace boost {
>namespace detail {
>namespace multi_array {
>
>
>
>
>
>
>template <typename T, std::size_t NumDims, typename TPtr>
>class const_sub_array :
> public boost::detail::multi_array::multi_array_impl_base<T,NumDims>
>{
> typedef boost::detail::multi_array::multi_array_impl_base<T,NumDims> super_type;
>public:
> typedef typename super_type::value_type value_type;
> typedef typename super_type::const_reference const_reference;
> typedef typename super_type::const_iterator const_iterator;
> typedef typename super_type::const_reverse_iterator const_reverse_iterator;
> typedef typename super_type::element element;
> typedef typename super_type::size_type size_type;
> typedef typename super_type::difference_type difference_type;
> typedef typename super_type::index index;
> typedef typename super_type::extent_range extent_range;
>
>
> template <std::size_t NDims>
> struct const_array_view {
> typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
> };
>
> template <std::size_t NDims>
> struct array_view {
> typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
> };
>
>
>
> template <typename OPtr>
> const_sub_array (const const_sub_array<T,NumDims,OPtr>& rhs) :
> base_(rhs.base_), extents_(rhs.extents_), strides_(rhs.strides_),
> index_base_(rhs.index_base_) {
> }
>
>
>
> const_reference operator[](index idx) const {
> return super_type::access(boost::type<const_reference>(),
> idx,base_,shape(),strides(),index_bases());
> }
>
> template <typename IndexList>
> const element& operator()(const IndexList& indices) const {
> boost::function_requires<
> CollectionConcept<IndexList> >();
> return super_type::access_element(boost::type<const element&>(),
> indices,origin(),
> shape(),strides(),index_bases());
> }
>
>
>
> template <int NDims>
>
>
>
> typename const_array_view<NDims>::type
> operator[](const boost::detail::multi_array::
> index_gen<NumDims,NDims>& indices)
> const {
> typedef typename const_array_view<NDims>::type return_type;
> return
> super_type::generate_array_view(boost::type<return_type>(),
> indices,
> shape(),
> strides(),
> index_bases(),
> base_);
> }
>
> template <typename OPtr>
> bool operator<(const const_sub_array<T,NumDims,OPtr>& rhs) const {
> return std::lexicographical_compare(begin(),end(),rhs.begin(),rhs.end());
> }
>
> template <typename OPtr>
> bool operator==(const const_sub_array<T,NumDims,OPtr>& rhs) const {
> if(std::equal(shape(),shape()+num_dimensions(),rhs.shape()))
> return std::equal(begin(),end(),rhs.begin());
> else return false;
> }
>
> template <typename OPtr>
> bool operator!=(const const_sub_array<T,NumDims,OPtr>& rhs) const {
> return !(*this == rhs);
> }
>
> template <typename OPtr>
> bool operator>(const const_sub_array<T,NumDims,OPtr>& rhs) const {
> return rhs < *this;
> }
>
> template <typename OPtr>
> bool operator<=(const const_sub_array<T,NumDims,OPtr>& rhs) const {
> return !(*this > rhs);
> }
>
> template <typename OPtr>
> bool operator>=(const const_sub_array<T,NumDims,OPtr>& rhs) const {
> return !(*this < rhs);
> }
>
> const_iterator begin() const {
> return const_iterator(*index_bases(),origin(),
> shape(),strides(),index_bases());
> }
>
> const_iterator end() const {
> return const_iterator(*index_bases()+(index)*shape(),origin(),
> shape(),strides(),index_bases());
> }
>
> const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
>
> const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
> TPtr origin() const { return base_; }
> size_type size() const { return extents_[0]; }
> size_type max_size() const { return num_elements(); }
> bool empty() const { return size() == 0; }
> size_type num_dimensions() const { return NumDims; }
> const size_type* shape() const { return extents_; }
> const index* strides() const { return strides_; }
> const index* index_bases() const { return index_base_; }
>
> size_type num_elements() const {
> return std::accumulate(shape(),shape() + num_dimensions(),
> size_type(1), std::multiplies<size_type>());
> }
>
>
>
>protected:
> template <typename,std::size_t> friend class value_accessor_n;
> template <typename,std::size_t,typename> friend class const_sub_array;
>
>
>
>
> const_sub_array (TPtr base,
> const size_type* extents,
> const index* strides,
> const index* index_base) :
> base_(base), extents_(extents), strides_(strides),
> index_base_(index_base) {
> }
>
> TPtr base_;
> const size_type* extents_;
> const index* strides_;
> const index* index_base_;
>private:
>
> const_sub_array& operator=(const const_sub_array&);
>};
>
>
>
>
>
>
>
>template <typename T, std::size_t NumDims>
>class sub_array : public const_sub_array<T,NumDims,T*>
>{
> typedef const_sub_array<T,NumDims,T*> super_type;
>public:
> typedef typename super_type::element element;
> typedef typename super_type::reference reference;
> typedef typename super_type::index index;
> typedef typename super_type::size_type size_type;
> typedef typename super_type::iterator iterator;
> typedef typename super_type::reverse_iterator reverse_iterator;
> typedef typename super_type::const_reference const_reference;
> typedef typename super_type::const_iterator const_iterator;
> typedef typename super_type::const_reverse_iterator const_reverse_iterator;
>
>
> template <std::size_t NDims>
> struct const_array_view {
> typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
> };
>
> template <std::size_t NDims>
> struct array_view {
> typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
> };
>
>
> template <typename ConstMultiArray>
> sub_array& operator=(const ConstMultiArray& other) {
> function_requires< boost::multi_array_concepts::ConstMultiArrayConcept<
> ConstMultiArray, NumDims> >();
>
>
> ((void)0);
> ((void)0)
> ;
>
> std::copy(other.begin(),other.end(),begin());
> return *this;
> }
>
>
> sub_array& operator=(const sub_array& other) {
> if (&other != this) {
>
> ((void)0);
> ((void)0)
>
> ;
>
> std::copy(other.begin(),other.end(),begin());
> }
> return *this;
> }
>
> T* origin() { return this->base_; }
> const T* origin() const { return this->base_; }
>
> reference operator[](index idx) {
> return super_type::access(boost::type<reference>(),
> idx,this->base_,this->shape(),this->strides(),
> this->index_bases());
> }
>
>
>
> template <int NDims>
>
>
>
> typename array_view<NDims>::type
> operator[](const boost::detail::multi_array::
> index_gen<NumDims,NDims>& indices) {
> typedef typename array_view<NDims>::type return_type;
> return
> super_type::generate_array_view(boost::type<return_type>(),
> indices,
> this->shape(),
> this->strides(),
> this->index_bases(),
> origin());
> }
>
> template <class IndexList>
> element& operator()(const IndexList& indices) {
> boost::function_requires<
> CollectionConcept<IndexList> >();
> return super_type::access_element(boost::type<element&>(),
> indices,origin(),
> this->shape(),this->strides(),
> this->index_bases());
> }
>
> iterator begin() {
> return iterator(*this->index_bases(),origin(),
> this->shape(),this->strides(),this->index_bases());
> }
>
> iterator end() {
> return iterator(*this->index_bases()+(index)*this->shape(),origin(),
> this->shape(),this->strides(),this->index_bases());
> }
>
>
> reverse_iterator rbegin() {
> reverse_iterator ri(end());
> return ri;
> }
>
> reverse_iterator rend() {
> reverse_iterator ri(begin());
> return ri;
> }
>
>
>
>
>
> template <class IndexList>
> const element& operator()(const IndexList& indices) const {
> boost::function_requires<
> CollectionConcept<IndexList> >();
> return super_type::operator()(indices);
> }
>
> const_reference operator[](index idx) const {
> return super_type::operator[](idx);
> }
>
>
>
> template <int NDims>
>
>
>
> typename const_array_view<NDims>::type
> operator[](const boost::detail::multi_array::
> index_gen<NumDims,NDims>& indices)
> const {
> return super_type::operator[](indices);
> }
>
> const_iterator begin() const {
> return super_type::begin();
> }
>
> const_iterator end() const {
> return super_type::end();
> }
>
> const_reverse_iterator rbegin() const {
> return super_type::rbegin();
> }
>
> const_reverse_iterator rend() const {
> return super_type::rend();
> }
>
>
>private:
> template <typename,std::size_t> friend class value_accessor_n;
>
>
>
>
> sub_array (T* base,
> const size_type* extents,
> const index* strides,
> const index* index_base) :
> super_type(base,extents,strides,index_base) {
> }
>
>};
>
>}
>}
>
>
>
>template <typename Array, int N>
>class subarray_gen {
> typedef typename Array::element element;
>public:
> typedef boost::detail::multi_array::sub_array<element,N> type;
>};
>
>template <typename Array, int N>
>class const_subarray_gen {
> typedef typename Array::element element;
>public:
> typedef boost::detail::multi_array::const_sub_array<element,N> type;
>};
>}
># 26 "/usr/include/boost/multi_array.hpp" 2 3 4
># 1 "/usr/include/boost/multi_array/multi_array_ref.hpp" 1 3 4
># 26 "/usr/include/boost/multi_array/multi_array_ref.hpp" 3 4
># 1 "/usr/include/boost/multi_array/view.hpp" 1 3 4
># 27 "/usr/include/boost/multi_array/view.hpp" 3 4
># 1 "/usr/include/boost/utility/enable_if.hpp" 1 3 4
># 24 "/usr/include/boost/utility/enable_if.hpp" 3 4
>namespace boost
>{
>
> template <bool B, class T = void>
> struct enable_if_c {
> typedef T type;
> };
>
> template <class T>
> struct enable_if_c<false, T> {};
>
> template <class Cond, class T = void>
> struct enable_if : public enable_if_c<Cond::value, T> {};
>
> template <bool B, class T>
> struct lazy_enable_if_c {
> typedef typename T::type type;
> };
>
> template <class T>
> struct lazy_enable_if_c<false, T> {};
>
> template <class Cond, class T>
> struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
>
>
> template <bool B, class T = void>
> struct disable_if_c {
> typedef T type;
> };
>
> template <class T>
> struct disable_if_c<true, T> {};
>
> template <class Cond, class T = void>
> struct disable_if : public disable_if_c<Cond::value, T> {};
>
> template <bool B, class T>
> struct lazy_disable_if_c {
> typedef typename T::type type;
> };
>
> template <class T>
> struct lazy_disable_if_c<true, T> {};
>
> template <class Cond, class T>
> struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
>
>}
># 28 "/usr/include/boost/multi_array/view.hpp" 2 3 4
>
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 32 "/usr/include/boost/multi_array/view.hpp" 2 3 4
>
>
>
>namespace boost {
>namespace detail {
>namespace multi_array {
>
>
>template <typename T, std::size_t NumDims, typename TPtr>
>class const_multi_array_view :
> public boost::detail::multi_array::multi_array_impl_base<T,NumDims>
>{
> typedef boost::detail::multi_array::multi_array_impl_base<T,NumDims> super_type;
>public:
> typedef typename super_type::value_type value_type;
> typedef typename super_type::const_reference const_reference;
> typedef typename super_type::const_iterator const_iterator;
> typedef typename super_type::const_reverse_iterator const_reverse_iterator;
> typedef typename super_type::element element;
> typedef typename super_type::size_type size_type;
> typedef typename super_type::difference_type difference_type;
> typedef typename super_type::index index;
> typedef typename super_type::extent_range extent_range;
>
>
> template <std::size_t NDims>
> struct const_array_view {
> typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
> };
>
> template <std::size_t NDims>
> struct array_view {
> typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
> };
>
> template <typename OPtr>
> const_multi_array_view(const
> const_multi_array_view<T,NumDims,OPtr>& other) :
> base_(other.base_), origin_offset_(other.origin_offset_),
> num_elements_(other.num_elements_), extent_list_(other.extent_list_),
> stride_list_(other.stride_list_), index_base_list_(other.index_base_list_)
> { }
>
>
> template <class BaseList>
>
>
>
> typename
> disable_if<typename boost::is_integral<BaseList>::type,void >::type
>
> reindex(const BaseList& values) {
> boost::function_requires<
> CollectionConcept<BaseList> >();
> boost::detail::multi_array::
> copy_n(values.begin(),num_dimensions(),index_base_list_.begin());
> origin_offset_ =
> this->calculate_indexing_offset(stride_list_,index_base_list_);
> }
>
> void reindex(index value) {
> index_base_list_.assign(value);
> origin_offset_ =
> this->calculate_indexing_offset(stride_list_,index_base_list_);
> }
>
> size_type num_dimensions() const { return NumDims; }
>
> size_type size() const { return extent_list_.front(); }
> size_type max_size() const { return num_elements(); }
> bool empty() const { return size() == 0; }
>
> const size_type* shape() const {
> return extent_list_.data();
> }
>
> const index* strides() const {
> return stride_list_.data();
> }
>
> const T* origin() const { return base_+origin_offset_; }
>
> size_type num_elements() const { return num_elements_; }
>
> const index* index_bases() const {
> return index_base_list_.data();
> }
>
> template <typename IndexList>
> const element& operator()(IndexList indices) const {
> boost::function_requires<
> CollectionConcept<IndexList> >();
> return super_type::access_element(boost::type<const element&>(),
> indices,origin(),
> shape(),strides(),index_bases());
> }
>
>
> const_reference operator[](index idx) const {
> return super_type::access(boost::type<const_reference>(),
> idx,origin(),
> shape(),strides(),
> index_bases());
> }
>
>
>
> template <int NDims>
>
>
>
> typename const_array_view<NDims>::type
> operator[](const boost::detail::multi_array::
> index_gen<NumDims,NDims>& indices)
> const {
> typedef typename const_array_view<NDims>::type return_type;
> return
> super_type::generate_array_view(boost::type<return_type>(),
> indices,
> shape(),
> strides(),
> index_bases(),
> origin());
> }
> const_iterator begin() const {
> return const_iterator(*index_bases(),origin(),
> shape(),strides(),index_bases());
> }
>
> const_iterator end() const {
> return const_iterator(*index_bases()+(index)*shape(),origin(),
> shape(),strides(),index_bases());
> }
>
> const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
>
> const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
>
> template <typename OPtr>
> bool operator==(const
> const_multi_array_view<T,NumDims,OPtr>& rhs)
> const {
> if(std::equal(extent_list_.begin(),
> extent_list_.end(),
> rhs.extent_list_.begin()))
> return std::equal(begin(),end(),rhs.begin());
> else return false;
> }
>
> template <typename OPtr>
> bool operator<(const
> const_multi_array_view<T,NumDims,OPtr>& rhs)
> const {
> return std::lexicographical_compare(begin(),end(),rhs.begin(),rhs.end());
> }
>
> template <typename OPtr>
> bool operator!=(const
> const_multi_array_view<T,NumDims,OPtr>& rhs)
> const {
> return !(*this == rhs);
> }
>
> template <typename OPtr>
> bool operator>(const
> const_multi_array_view<T,NumDims,OPtr>& rhs)
> const {
> return rhs < *this;
> }
>
> template <typename OPtr>
> bool operator<=(const
> const_multi_array_view<T,NumDims,OPtr>& rhs)
> const {
> return !(*this > rhs);
> }
>
> template <typename OPtr>
> bool operator>=(const
> const_multi_array_view<T,NumDims,OPtr>& rhs)
> const {
> return !(*this < rhs);
> }
>
>
>
>protected:
> template <typename,std::size_t> friend class multi_array_impl_base;
> template <typename,std::size_t,typename> friend class const_multi_array_view;
>
>
>
>
>
>
> template <typename ExtentList, typename Index>
> explicit const_multi_array_view(TPtr base,
> const ExtentList& extents,
> const boost::array<Index,NumDims>& strides):
> base_(base), origin_offset_(0) {
>
> index_base_list_.assign(0);
>
>
> boost::detail::multi_array::
> copy_n(extents.begin(),NumDims,extent_list_.begin());
> boost::detail::multi_array::
> copy_n(strides.begin(),NumDims,stride_list_.begin());
>
>
> num_elements_ = std::accumulate(extent_list_.begin(),extent_list_.end(),
> size_type(1),std::multiplies<size_type>());
> }
>
> typedef boost::array<size_type,NumDims> size_list;
> typedef boost::array<index,NumDims> index_list;
>
> TPtr base_;
> index origin_offset_;
> size_type num_elements_;
> size_list extent_list_;
> index_list stride_list_;
> index_list index_base_list_;
>
>private:
>
> const_multi_array_view& operator=(const const_multi_array_view& other);
>};
>
>
>template <typename T, std::size_t NumDims>
>class multi_array_view :
> public const_multi_array_view<T,NumDims,T*>
>{
> typedef const_multi_array_view<T,NumDims,T*> super_type;
>public:
> typedef typename super_type::value_type value_type;
> typedef typename super_type::reference reference;
> typedef typename super_type::iterator iterator;
> typedef typename super_type::reverse_iterator reverse_iterator;
> typedef typename super_type::const_reference const_reference;
> typedef typename super_type::const_iterator const_iterator;
> typedef typename super_type::const_reverse_iterator const_reverse_iterator;
> typedef typename super_type::element element;
> typedef typename super_type::size_type size_type;
> typedef typename super_type::difference_type difference_type;
> typedef typename super_type::index index;
> typedef typename super_type::extent_range extent_range;
>
>
> template <std::size_t NDims>
> struct const_array_view {
> typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
> };
>
> template <std::size_t NDims>
> struct array_view {
> typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
> };
>
>
> template <typename ConstMultiArray>
> multi_array_view& operator=(const ConstMultiArray& other) {
> function_requires<
> boost::multi_array_concepts::
> ConstMultiArrayConcept<ConstMultiArray,NumDims> >();
>
>
> ((void)0);
> ((void)0)
> ;
>
> std::copy(other.begin(),other.end(),begin());
> return *this;
> }
>
>
> multi_array_view& operator=(const multi_array_view& other) {
> if (&other != this) {
>
> ((void)0);
> ((void)0)
>
> ;
>
> std::copy(other.begin(),other.end(),begin());
> }
> return *this;
> }
>
> element* origin() { return this->base_+this->origin_offset_; }
>
> template <class IndexList>
> element& operator()(const IndexList& indices) {
> boost::function_requires<
> CollectionConcept<IndexList> >();
> return super_type::access_element(boost::type<element&>(),
> indices,origin(),
> this->shape(),this->strides(),
> this->index_bases());
> }
>
>
> reference operator[](index idx) {
> return super_type::access(boost::type<reference>(),
> idx,origin(),
> this->shape(),this->strides(),
> this->index_bases());
> }
>
>
>
>
> template <int NDims>
>
>
>
> typename array_view<NDims>::type
> operator[](const boost::detail::multi_array::
> index_gen<NumDims,NDims>& indices) {
> typedef typename array_view<NDims>::type return_type;
> return
> super_type::generate_array_view(boost::type<return_type>(),
> indices,
> this->shape(),
> this->strides(),
> this->index_bases(),
> origin());
> }
>
>
> iterator begin() {
> return iterator(*this->index_bases(),origin(),
> this->shape(),this->strides(),
> this->index_bases());
> }
>
> iterator end() {
> return iterator(*this->index_bases()+(index)*this->shape(),origin(),
> this->shape(),this->strides(),
> this->index_bases());
> }
>
> reverse_iterator rbegin() {
> return reverse_iterator(end());
> }
>
> reverse_iterator rend() {
> return reverse_iterator(begin());
> }
>
>
>
>
> const element* origin() const { return super_type::origin(); }
>
> template <class IndexList>
> const element& operator()(const IndexList& indices) const {
> boost::function_requires<
> CollectionConcept<IndexList> >();
> return super_type::operator()(indices);
> }
>
> const_reference operator[](index idx) const {
> return super_type::operator[](idx);
> }
>
>
>
> template <int NDims>
>
>
>
> typename const_array_view<NDims>::type
> operator[](const boost::detail::multi_array::
> index_gen<NumDims,NDims>& indices)
> const {
> return super_type::operator[](indices);
> }
>
> const_iterator begin() const {
> return super_type::begin();
> }
>
> const_iterator end() const {
> return super_type::end();
> }
>
> const_reverse_iterator rbegin() const {
> return super_type::rbegin();
> }
>
> const_reverse_iterator rend() const {
> return super_type::rend();
> }
>
>
>private:
> template <typename,std::size_t> friend class multi_array_impl_base;
>
>
>
>
>
>
> template <typename ExtentList, typename Index>
> explicit multi_array_view(T* base,
> const ExtentList& extents,
> const boost::array<Index,NumDims>& strides) :
> super_type(base,extents,strides) { }
>
>};
>
>}
>}
>
>
>
>
>template <typename Array, int N>
>class array_view_gen {
> typedef typename Array::element element;
>public:
> typedef boost::detail::multi_array::multi_array_view<element,N> type;
>};
>
>template <typename Array, int N>
>class const_array_view_gen {
> typedef typename Array::element element;
>public:
> typedef boost::detail::multi_array::const_multi_array_view<element,N> type;
>};
>
>}
># 27 "/usr/include/boost/multi_array/multi_array_ref.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/functional.hpp" 1 3 4
># 19 "/usr/include/boost/functional.hpp" 3 4
>namespace boost
>{
># 35 "/usr/include/boost/functional.hpp" 3 4
> namespace detail
> {
> template <class Operation>
> struct unary_traits_imp;
>
> template <class Operation>
> struct unary_traits_imp<Operation*>
> {
> typedef Operation function_type;
> typedef const function_type & param_type;
> typedef typename Operation::result_type result_type;
> typedef typename Operation::argument_type argument_type;
> };
>
> template <class R, class A>
> struct unary_traits_imp<R(*)(A)>
> {
> typedef R (*function_type)(A);
> typedef R (*param_type)(A);
> typedef R result_type;
> typedef A argument_type;
> };
>
> template <class Operation>
> struct binary_traits_imp;
>
> template <class Operation>
> struct binary_traits_imp<Operation*>
> {
> typedef Operation function_type;
> typedef const function_type & param_type;
> typedef typename Operation::result_type result_type;
> typedef typename Operation::first_argument_type first_argument_type;
> typedef typename Operation::second_argument_type second_argument_type;
> };
>
> template <class R, class A1, class A2>
> struct binary_traits_imp<R(*)(A1,A2)>
> {
> typedef R (*function_type)(A1,A2);
> typedef R (*param_type)(A1,A2);
> typedef R result_type;
> typedef A1 first_argument_type;
> typedef A2 second_argument_type;
> };
> }
>
> template <class Operation>
> struct unary_traits
> {
> typedef typename detail::unary_traits_imp<Operation*>::function_type function_type;
> typedef typename detail::unary_traits_imp<Operation*>::param_type param_type;
> typedef typename detail::unary_traits_imp<Operation*>::result_type result_type;
> typedef typename detail::unary_traits_imp<Operation*>::argument_type argument_type;
> };
>
> template <class R, class A>
> struct unary_traits<R(*)(A)>
> {
> typedef R (*function_type)(A);
> typedef R (*param_type)(A);
> typedef R result_type;
> typedef A argument_type;
> };
>
> template <class Operation>
> struct binary_traits
> {
> typedef typename detail::binary_traits_imp<Operation*>::function_type function_type;
> typedef typename detail::binary_traits_imp<Operation*>::param_type param_type;
> typedef typename detail::binary_traits_imp<Operation*>::result_type result_type;
> typedef typename detail::binary_traits_imp<Operation*>::first_argument_type first_argument_type;
> typedef typename detail::binary_traits_imp<Operation*>::second_argument_type second_argument_type;
> };
>
> template <class R, class A1, class A2>
> struct binary_traits<R(*)(A1,A2)>
> {
> typedef R (*function_type)(A1,A2);
> typedef R (*param_type)(A1,A2);
> typedef R result_type;
> typedef A1 first_argument_type;
> typedef A2 second_argument_type;
> };
># 148 "/usr/include/boost/functional.hpp" 3 4
> template <class Predicate>
> class unary_negate
> : public std::unary_function<typename unary_traits<Predicate>::argument_type,bool>
> {
> public:
> explicit unary_negate(typename unary_traits<Predicate>::param_type x)
> :
> pred(x)
> {}
> bool operator()(typename call_traits<typename unary_traits<Predicate>::argument_type>::param_type x) const
> {
> return !pred(x);
> }
> private:
> typename unary_traits<Predicate>::function_type pred;
> };
>
> template <class Predicate>
> unary_negate<Predicate> not1(const Predicate &pred)
> {
>
>
> return unary_negate<Predicate>((typename unary_traits<Predicate>::param_type)pred);
> }
>
> template <class Predicate>
> unary_negate<Predicate> not1(Predicate &pred)
> {
> return unary_negate<Predicate>(pred);
> }
>
>
>
>
> template <class Predicate>
> class binary_negate
> : public std::binary_function<typename binary_traits<Predicate>::first_argument_type,
> typename binary_traits<Predicate>::second_argument_type,
> bool>
> {
> public:
> explicit binary_negate(typename binary_traits<Predicate>::param_type x)
> :
> pred(x)
> {}
> bool operator()(typename call_traits<typename binary_traits<Predicate>::first_argument_type>::param_type x,
> typename call_traits<typename binary_traits<Predicate>::second_argument_type>::param_type y) const
> {
> return !pred(x,y);
> }
> private:
> typename binary_traits<Predicate>::function_type pred;
> };
>
> template <class Predicate>
> binary_negate<Predicate> not2(const Predicate &pred)
> {
>
>
> return binary_negate<Predicate>((typename binary_traits<Predicate>::param_type)pred);
> }
>
> template <class Predicate>
> binary_negate<Predicate> not2(Predicate &pred)
> {
> return binary_negate<Predicate>(pred);
> }
>
>
>
>
> template <class Operation>
> class binder1st
> : public std::unary_function<typename binary_traits<Operation>::second_argument_type,
> typename binary_traits<Operation>::result_type>
> {
> public:
> binder1st(typename binary_traits<Operation>::param_type x,
> typename call_traits<typename binary_traits<Operation>::first_argument_type>::param_type y)
> :
> op(x), value(y)
> {}
>
> typename binary_traits<Operation>::result_type
> operator()(typename call_traits<typename binary_traits<Operation>::second_argument_type>::param_type x) const
> {
> return op(value, x);
> }
>
> protected:
> typename binary_traits<Operation>::function_type op;
> typename binary_traits<Operation>::first_argument_type value;
> };
>
> template <class Operation>
> inline binder1st<Operation> bind1st(const Operation &op,
> typename call_traits<
> typename binary_traits<Operation>::first_argument_type
> >::param_type x)
> {
>
>
> return binder1st<Operation>((typename binary_traits<Operation>::param_type)op, x);
> }
>
> template <class Operation>
> inline binder1st<Operation> bind1st(Operation &op,
> typename call_traits<
> typename binary_traits<Operation>::first_argument_type
> >::param_type x)
> {
> return binder1st<Operation>(op, x);
> }
>
>
>
>
> template <class Operation>
> class binder2nd
> : public std::unary_function<typename binary_traits<Operation>::first_argument_type,
> typename binary_traits<Operation>::result_type>
> {
> public:
> binder2nd(typename binary_traits<Operation>::param_type x,
> typename call_traits<typename binary_traits<Operation>::second_argument_type>::param_type y)
> :
> op(x), value(y)
> {}
>
> typename binary_traits<Operation>::result_type
> operator()(typename call_traits<typename binary_traits<Operation>::first_argument_type>::param_type x) const
> {
> return op(x, value);
> }
>
> protected:
> typename binary_traits<Operation>::function_type op;
> typename binary_traits<Operation>::second_argument_type value;
> };
>
> template <class Operation>
> inline binder2nd<Operation> bind2nd(const Operation &op,
> typename call_traits<
> typename binary_traits<Operation>::second_argument_type
> >::param_type x)
> {
>
>
> return binder2nd<Operation>((typename binary_traits<Operation>::param_type)op, x);
> }
>
> template <class Operation>
> inline binder2nd<Operation> bind2nd(Operation &op,
> typename call_traits<
> typename binary_traits<Operation>::second_argument_type
> >::param_type x)
> {
> return binder2nd<Operation>(op, x);
> }
>
>
>
>
> template <class S, class T>
> class mem_fun_t : public std::unary_function<T*, S>
> {
> public:
> explicit mem_fun_t(S (T::*p)())
> :
> ptr(p)
> {}
> S operator()(T* p) const
> {
> return (p->*ptr)();
> }
> private:
> S (T::*ptr)();
> };
>
> template <class S, class T, class A>
> class mem_fun1_t : public std::binary_function<T*, A, S>
> {
> public:
> explicit mem_fun1_t(S (T::*p)(A))
> :
> ptr(p)
> {}
> S operator()(T* p, typename call_traits<A>::param_type x) const
> {
> return (p->*ptr)(x);
> }
> private:
> S (T::*ptr)(A);
> };
>
> template <class S, class T>
> class const_mem_fun_t : public std::unary_function<const T*, S>
> {
> public:
> explicit const_mem_fun_t(S (T::*p)() const)
> :
> ptr(p)
> {}
> S operator()(const T* p) const
> {
> return (p->*ptr)();
> }
> private:
> S (T::*ptr)() const;
> };
>
> template <class S, class T, class A>
> class const_mem_fun1_t : public std::binary_function<const T*, A, S>
> {
> public:
> explicit const_mem_fun1_t(S (T::*p)(A) const)
> :
> ptr(p)
> {}
> S operator()(const T* p, typename call_traits<A>::param_type x) const
> {
> return (p->*ptr)(x);
> }
> private:
> S (T::*ptr)(A) const;
> };
>
> template<class S, class T>
> inline mem_fun_t<S,T> mem_fun(S (T::*f)())
> {
> return mem_fun_t<S,T>(f);
> }
>
> template<class S, class T, class A>
> inline mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A))
> {
> return mem_fun1_t<S,T,A>(f);
> }
>
>
> template<class S, class T>
> inline const_mem_fun_t<S,T> mem_fun(S (T::*f)() const)
> {
> return const_mem_fun_t<S,T>(f);
> }
>
> template<class S, class T, class A>
> inline const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const)
> {
> return const_mem_fun1_t<S,T,A>(f);
> }
>
>
>
>
>
> template <class S, class T>
> class mem_fun_ref_t : public std::unary_function<T&, S>
> {
> public:
> explicit mem_fun_ref_t(S (T::*p)())
> :
> ptr(p)
> {}
> S operator()(T& p) const
> {
> return (p.*ptr)();
> }
> private:
> S (T::*ptr)();
> };
>
> template <class S, class T, class A>
> class mem_fun1_ref_t : public std::binary_function<T&, A, S>
> {
> public:
> explicit mem_fun1_ref_t(S (T::*p)(A))
> :
> ptr(p)
> {}
> S operator()(T& p, typename call_traits<A>::param_type x) const
> {
> return (p.*ptr)(x);
> }
> private:
> S (T::*ptr)(A);
> };
>
> template <class S, class T>
> class const_mem_fun_ref_t : public std::unary_function<const T&, S>
> {
> public:
> explicit const_mem_fun_ref_t(S (T::*p)() const)
> :
> ptr(p)
> {}
>
> S operator()(const T &p) const
> {
> return (p.*ptr)();
> }
> private:
> S (T::*ptr)() const;
> };
>
> template <class S, class T, class A>
> class const_mem_fun1_ref_t : public std::binary_function<const T&, A, S>
> {
> public:
> explicit const_mem_fun1_ref_t(S (T::*p)(A) const)
> :
> ptr(p)
> {}
>
> S operator()(const T& p, typename call_traits<A>::param_type x) const
> {
> return (p.*ptr)(x);
> }
> private:
> S (T::*ptr)(A) const;
> };
>
> template<class S, class T>
> inline mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)())
> {
> return mem_fun_ref_t<S,T>(f);
> }
>
> template<class S, class T, class A>
> inline mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A))
> {
> return mem_fun1_ref_t<S,T,A>(f);
> }
>
>
> template<class S, class T>
> inline const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const)
> {
> return const_mem_fun_ref_t<S,T>(f);
> }
>
> template<class S, class T, class A>
> inline const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const)
> {
> return const_mem_fun1_ref_t<S,T,A>(f);
> }
>
>
>
>
>
> template <class Arg, class Result>
> class pointer_to_unary_function : public std::unary_function<Arg,Result>
> {
> public:
> explicit pointer_to_unary_function(Result (*f)(Arg))
> :
> func(f)
> {}
>
> Result operator()(typename call_traits<Arg>::param_type x) const
> {
> return func(x);
> }
>
> private:
> Result (*func)(Arg);
> };
>
> template <class Arg, class Result>
> inline pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg))
> {
> return pointer_to_unary_function<Arg,Result>(f);
> }
>
> template <class Arg1, class Arg2, class Result>
> class pointer_to_binary_function : public std::binary_function<Arg1,Arg2,Result>
> {
> public:
> explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2))
> :
> func(f)
> {}
>
> Result operator()(typename call_traits<Arg1>::param_type x, typename call_traits<Arg2>::param_type y) const
> {
> return func(x,y);
> }
>
> private:
> Result (*func)(Arg1, Arg2);
> };
>
> template <class Arg1, class Arg2, class Result>
> inline pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1, Arg2))
> {
> return pointer_to_binary_function<Arg1,Arg2,Result>(f);
> }
>}
># 33 "/usr/include/boost/multi_array/multi_array_ref.hpp" 2 3 4
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 36 "/usr/include/boost/multi_array/multi_array_ref.hpp" 2 3 4
>
>
>
>namespace boost {
>
>template <typename T, std::size_t NumDims,
> typename TPtr = const T*
>>
>class const_multi_array_ref :
> public detail::multi_array::multi_array_impl_base<T,NumDims>
>{
> typedef detail::multi_array::multi_array_impl_base<T,NumDims> super_type;
>public:
> typedef typename super_type::value_type value_type;
> typedef typename super_type::const_reference const_reference;
> typedef typename super_type::const_iterator const_iterator;
> typedef typename super_type::const_reverse_iterator const_reverse_iterator;
> typedef typename super_type::element element;
> typedef typename super_type::size_type size_type;
> typedef typename super_type::difference_type difference_type;
> typedef typename super_type::index index;
> typedef typename super_type::extent_range extent_range;
> typedef general_storage_order<NumDims> storage_order_type;
>
>
> template <std::size_t NDims>
> struct const_array_view {
> typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
> };
>
> template <std::size_t NDims>
> struct array_view {
> typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
> };
>
>
>
> template <typename,std::size_t,typename>
> friend class const_multi_array_ref;
>
>
>
>
> template <typename OPtr>
> const_multi_array_ref(const const_multi_array_ref<T,NumDims,OPtr>& other)
> : base_(other.base_), storage_(other.storage_),
> extent_list_(other.extent_list_),
> stride_list_(other.stride_list_),
> index_base_list_(other.index_base_list_),
> origin_offset_(other.origin_offset_),
> directional_offset_(other.directional_offset_),
> num_elements_(other.num_elements_) { }
>
> template <typename ExtentList>
> explicit const_multi_array_ref(TPtr base, const ExtentList& extents) :
> base_(base), storage_(c_storage_order()) {
> boost::function_requires<
> CollectionConcept<ExtentList> >();
>
> index_base_list_.assign(0);
> init_multi_array_ref(extents.begin());
> }
>
> template <typename ExtentList>
> explicit const_multi_array_ref(TPtr base, const ExtentList& extents,
> const general_storage_order<NumDims>& so) :
> base_(base), storage_(so) {
> boost::function_requires<
> CollectionConcept<ExtentList> >();
>
> index_base_list_.assign(0);
> init_multi_array_ref(extents.begin());
> }
>
> explicit const_multi_array_ref(TPtr base,
> const detail::multi_array::
> extent_gen<NumDims>& ranges) :
> base_(base), storage_(c_storage_order()) {
>
> init_from_extent_gen(ranges);
> }
>
> explicit const_multi_array_ref(TPtr base,
> const detail::multi_array::
> extent_gen<NumDims>& ranges,
> const general_storage_order<NumDims>& so) :
> base_(base), storage_(so) {
>
> init_from_extent_gen(ranges);
> }
>
> template <class InputIterator>
> void assign(InputIterator begin, InputIterator end) {
> boost::function_requires<InputIteratorConcept<InputIterator> >();
>
> InputIterator in_iter = begin;
> T* out_iter = base_;
> std::size_t copy_count=0;
> while (in_iter != end && copy_count < num_elements_) {
> *out_iter++ = *in_iter++;
> copy_count++;
> }
> }
>
> template <class BaseList>
>
>
>
> typename
> disable_if<typename boost::is_integral<BaseList>::type,void >::type
>
> reindex(const BaseList& values) {
> boost::function_requires<
> CollectionConcept<BaseList> >();
> boost::detail::multi_array::
> copy_n(values.begin(),num_dimensions(),index_base_list_.begin());
> origin_offset_ =
> this->calculate_origin_offset(stride_list_,extent_list_,
> storage_,index_base_list_);
> }
>
> void reindex(index value) {
> index_base_list_.assign(value);
> origin_offset_ =
> this->calculate_origin_offset(stride_list_,extent_list_,
> storage_,index_base_list_);
> }
>
> template <typename SizeList>
> void reshape(const SizeList& extents) {
> boost::function_requires<
> CollectionConcept<SizeList> >();
> ((void)0)
>
> ;
>
> std::copy(extents.begin(),extents.end(),extent_list_.begin());
> this->compute_strides(stride_list_,extent_list_,storage_);
>
> origin_offset_ =
> this->calculate_origin_offset(stride_list_,extent_list_,
> storage_,index_base_list_);
> }
>
> size_type num_dimensions() const { return NumDims; }
>
> size_type size() const { return extent_list_.front(); }
>
>
> size_type max_size() const { return num_elements(); }
>
> bool empty() const { return size() == 0; }
>
> const size_type* shape() const {
> return extent_list_.data();
> }
>
> const index* strides() const {
> return stride_list_.data();
> }
>
> const element* origin() const { return base_+origin_offset_; }
> const element* data() const { return base_; }
>
> size_type num_elements() const { return num_elements_; }
>
> const index* index_bases() const {
> return index_base_list_.data();
> }
>
>
> const storage_order_type& storage_order() const {
> return storage_;
> }
>
> template <typename IndexList>
> const element& operator()(IndexList indices) const {
> boost::function_requires<
> CollectionConcept<IndexList> >();
> return super_type::access_element(boost::type<const element&>(),
> indices,origin(),
> shape(),strides(),index_bases());
> }
>
>
> const_reference operator[](index idx) const {
> return super_type::access(boost::type<const_reference>(),
> idx,origin(),
> shape(),strides(),index_bases());
> }
>
>
>
> template <int NDims>
>
>
>
> typename const_array_view<NDims>::type
> operator[](const detail::multi_array::
> index_gen<NumDims,NDims>& indices)
> const {
> typedef typename const_array_view<NDims>::type return_type;
> return
> super_type::generate_array_view(boost::type<return_type>(),
> indices,
> shape(),
> strides(),
> index_bases(),
> origin());
> }
>
> const_iterator begin() const {
> return const_iterator(*index_bases(),origin(),
> shape(),strides(),index_bases());
> }
>
> const_iterator end() const {
> return const_iterator(*index_bases()+(index)*shape(),origin(),
> shape(),strides(),index_bases());
> }
>
> const_reverse_iterator rbegin() const {
> return const_reverse_iterator(end());
> }
>
> const_reverse_iterator rend() const {
> return const_reverse_iterator(begin());
> }
>
>
> template <typename OPtr>
> bool operator==(const
> const_multi_array_ref<T,NumDims,OPtr>& rhs)
> const {
> if(std::equal(extent_list_.begin(),
> extent_list_.end(),
> rhs.extent_list_.begin()))
> return std::equal(begin(),end(),rhs.begin());
> else return false;
> }
>
> template <typename OPtr>
> bool operator<(const
> const_multi_array_ref<T,NumDims,OPtr>& rhs)
> const {
> return std::lexicographical_compare(begin(),end(),rhs.begin(),rhs.end());
> }
>
> template <typename OPtr>
> bool operator!=(const
> const_multi_array_ref<T,NumDims,OPtr>& rhs)
> const {
> return !(*this == rhs);
> }
>
> template <typename OPtr>
> bool operator>(const
> const_multi_array_ref<T,NumDims,OPtr>& rhs)
> const {
> return rhs < *this;
> }
>
> template <typename OPtr>
> bool operator<=(const
> const_multi_array_ref<T,NumDims,OPtr>& rhs)
> const {
> return !(*this > rhs);
> }
>
> template <typename OPtr>
> bool operator>=(const
> const_multi_array_ref<T,NumDims,OPtr>& rhs)
> const {
> return !(*this < rhs);
> }
>
>
>
>protected:
>
>
>
>
> typedef boost::array<size_type,NumDims> size_list;
> typedef boost::array<index,NumDims> index_list;
>
>
> void set_base_ptr(TPtr new_base) { base_ = new_base; }
>
>
>
>
> explicit
> const_multi_array_ref(TPtr base,
> const storage_order_type& so,
> const index * index_bases,
> const size_type* extents) :
> base_(base), storage_(so), origin_offset_(0), directional_offset_(0)
> {
>
>
> if(index_bases) {
> boost::detail::multi_array::
> copy_n(index_bases,NumDims,index_base_list_.begin());
> } else {
> std::fill_n(index_base_list_.begin(),NumDims,0);
> }
> if(extents) {
> init_multi_array_ref(extents);
> } else {
> boost::array<index,NumDims> extent_list;
> extent_list.assign(0);
> init_multi_array_ref(extent_list.begin());
> }
> }
>
>
> TPtr base_;
> storage_order_type storage_;
> size_list extent_list_;
> index_list stride_list_;
> index_list index_base_list_;
> index origin_offset_;
> index directional_offset_;
> size_type num_elements_;
>
>private:
>
> const_multi_array_ref& operator=(const const_multi_array_ref& other);
>
> void init_from_extent_gen(const
> detail::multi_array::
> extent_gen<NumDims>& ranges) {
>
> typedef boost::array<index,NumDims> extent_list;
>
>
> std::transform(ranges.ranges_.begin(),ranges.ranges_.end(),
> index_base_list_.begin(),
> boost::mem_fun_ref(&extent_range::start));
>
>
> extent_list extents;
> std::transform(ranges.ranges_.begin(),ranges.ranges_.end(),
> extents.begin(),
> boost::mem_fun_ref(&extent_range::size));
>
> init_multi_array_ref(extents.begin());
> }
>
>
>
>protected:
>
>
>
>
> template <class InputIterator>
> void init_multi_array_ref(InputIterator extents_iter) {
> boost::function_requires<InputIteratorConcept<InputIterator> >();
>
> boost::detail::multi_array::
> copy_n(extents_iter,num_dimensions(),extent_list_.begin());
>
>
> num_elements_ = std::accumulate(extent_list_.begin(),extent_list_.end(),
> size_type(1),std::multiplies<size_type>());
>
> this->compute_strides(stride_list_,extent_list_,storage_);
>
> origin_offset_ =
> this->calculate_origin_offset(stride_list_,extent_list_,
> storage_,index_base_list_);
> directional_offset_ =
> this->calculate_descending_dimension_offset(stride_list_,extent_list_,
> storage_);
> }
>};
>
>template <typename T, std::size_t NumDims>
>class multi_array_ref :
> public const_multi_array_ref<T,NumDims,T*>
>{
> typedef const_multi_array_ref<T,NumDims,T*> super_type;
>public:
> typedef typename super_type::value_type value_type;
> typedef typename super_type::reference reference;
> typedef typename super_type::iterator iterator;
> typedef typename super_type::reverse_iterator reverse_iterator;
> typedef typename super_type::const_reference const_reference;
> typedef typename super_type::const_iterator const_iterator;
> typedef typename super_type::const_reverse_iterator const_reverse_iterator;
> typedef typename super_type::element element;
> typedef typename super_type::size_type size_type;
> typedef typename super_type::difference_type difference_type;
> typedef typename super_type::index index;
> typedef typename super_type::extent_range extent_range;
>
> typedef typename super_type::storage_order_type storage_order_type;
> typedef typename super_type::index_list index_list;
> typedef typename super_type::size_list size_list;
>
> template <std::size_t NDims>
> struct const_array_view {
> typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
> };
>
> template <std::size_t NDims>
> struct array_view {
> typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
> };
>
> template <class ExtentList>
> explicit multi_array_ref(T* base, const ExtentList& extents) :
> super_type(base,extents) {
> boost::function_requires<
> CollectionConcept<ExtentList> >();
> }
>
> template <class ExtentList>
> explicit multi_array_ref(T* base, const ExtentList& extents,
> const general_storage_order<NumDims>& so) :
> super_type(base,extents,so) {
> boost::function_requires<
> CollectionConcept<ExtentList> >();
> }
>
>
> explicit multi_array_ref(T* base,
> const detail::multi_array::
> extent_gen<NumDims>& ranges) :
> super_type(base,ranges) { }
>
>
> explicit multi_array_ref(T* base,
> const detail::multi_array::
> extent_gen<NumDims>&
> ranges,
> const general_storage_order<NumDims>& so) :
> super_type(base,ranges,so) { }
>
>
>
> template <typename ConstMultiArray>
> multi_array_ref& operator=(const ConstMultiArray& other) {
> function_requires<
> multi_array_concepts::
> ConstMultiArrayConcept<ConstMultiArray,NumDims> >();
>
>
> ((void)0);
> ((void)0)
> ;
>
> std::copy(other.begin(),other.end(),this->begin());
> return *this;
> }
>
> multi_array_ref& operator=(const multi_array_ref& other) {
> if (&other != this) {
>
>
> ((void)0);
> ((void)0)
>
> ;
>
> std::copy(other.begin(),other.end(),this->begin());
> }
> return *this;
> }
>
> element* origin() { return super_type::base_+super_type::origin_offset_; }
>
> element* data() { return super_type::base_; }
>
> template <class IndexList>
> element& operator()(const IndexList& indices) {
> boost::function_requires<
> CollectionConcept<IndexList> >();
> return super_type::access_element(boost::type<element&>(),
> indices,origin(),
> this->shape(),this->strides(),
> this->index_bases());
> }
>
>
> reference operator[](index idx) {
> return super_type::access(boost::type<reference>(),
> idx,origin(),
> this->shape(),this->strides(),
> this->index_bases());
> }
>
>
>
>
> template <int NDims>
>
>
>
> typename array_view<NDims>::type
> operator[](const detail::multi_array::
> index_gen<NumDims,NDims>& indices) {
> typedef typename array_view<NDims>::type return_type;
> return
> super_type::generate_array_view(boost::type<return_type>(),
> indices,
> this->shape(),
> this->strides(),
> this->index_bases(),
> origin());
> }
>
>
> iterator begin() {
> return iterator(*this->index_bases(),origin(),this->shape(),
> this->strides(),this->index_bases());
> }
>
> iterator end() {
> return iterator(*this->index_bases()+(index)*this->shape(),origin(),
> this->shape(),this->strides(),
> this->index_bases());
> }
>
>
> reverse_iterator rbegin() {
> reverse_iterator ri(end());
> return ri;
> }
>
> reverse_iterator rend() {
> reverse_iterator ri(begin());
> return ri;
> }
>
>
>
>
> const element* origin() const { return super_type::origin(); }
> const element* data() const { return super_type::data(); }
>
> template <class IndexList>
> const element& operator()(const IndexList& indices) const {
> boost::function_requires<
> CollectionConcept<IndexList> >();
> return super_type::operator()(indices);
> }
>
> const_reference operator[](index idx) const {
> return super_type::access(boost::type<const_reference>(),
> idx,origin(),
> this->shape(),this->strides(),
> this->index_bases());
> }
>
>
>
> template <int NDims>
>
>
>
> typename const_array_view<NDims>::type
> operator[](const detail::multi_array::
> index_gen<NumDims,NDims>& indices)
> const {
> return super_type::operator[](indices);
> }
>
> const_iterator begin() const {
> return super_type::begin();
> }
>
> const_iterator end() const {
> return super_type::end();
> }
>
> const_reverse_iterator rbegin() const {
> return super_type::rbegin();
> }
>
> const_reverse_iterator rend() const {
> return super_type::rend();
> }
>
>protected:
>
> explicit multi_array_ref(T* base,
> const storage_order_type& so,
> const index* index_bases,
> const size_type* extents) :
> super_type(base,so,index_bases,extents) { }
>
>};
>
>}
># 27 "/usr/include/boost/multi_array.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/type_traits.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits.hpp" 3 4
># 1 "/usr/include/boost/type_traits/add_cv.hpp" 1 3 4
># 17 "/usr/include/boost/type_traits/add_cv.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 18 "/usr/include/boost/type_traits/add_cv.hpp" 2 3 4
>
>namespace boost {
># 34 "/usr/include/boost/type_traits/add_cv.hpp" 3 4
>template< typename T > struct add_cv { public: typedef T const volatile type; };
>
>
>
>
>
>
>template< typename T > struct add_cv<T&> { public: typedef T& type; };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 47 "/usr/include/boost/type_traits/add_cv.hpp" 2 3 4
># 15 "/usr/include/boost/type_traits.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/type_traits/add_volatile.hpp" 1 3 4
># 16 "/usr/include/boost/type_traits/add_volatile.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 17 "/usr/include/boost/type_traits/add_volatile.hpp" 2 3 4
>
>namespace boost {
># 33 "/usr/include/boost/type_traits/add_volatile.hpp" 3 4
>template< typename T > struct add_volatile { public: typedef T volatile type; };
>
>
>
>
>
>
>template< typename T > struct add_volatile<T&> { public: typedef T& type; };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 46 "/usr/include/boost/type_traits/add_volatile.hpp" 2 3 4
># 20 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/aligned_storage.hpp" 1 3 4
># 11 "/usr/include/boost/type_traits/aligned_storage.hpp" 3 4
># 1 "/usr/include/boost/aligned_storage.hpp" 1 3 4
># 16 "/usr/include/boost/aligned_storage.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 17 "/usr/include/boost/aligned_storage.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/type_traits/alignment_of.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 14 "/usr/include/boost/type_traits/alignment_of.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 2 3 4
># 18 "/usr/include/boost/type_traits/alignment_of.hpp" 2 3 4
># 27 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
>namespace boost {
>
>template <typename T> struct alignment_of;
>
>
>namespace detail {
>
>
>
>
>
>template <typename T>
>struct alignment_of_hack
>{
> char c;
> T t;
> alignment_of_hack();
>};
>
>
>
>
>template <unsigned A, unsigned S>
>struct alignment_logic
>{
> static const std::size_t value = A < S ? A : S;
>};
>
>
>template< typename T >
>struct alignment_of_impl
>{
># 83 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
> static const std::size_t value = __alignof__(T);
>
>};
>
>}
>
>template< typename T > struct alignment_of : public ::boost::integral_constant<std::size_t,::boost::detail::alignment_of_impl<T>::value> { public: };
>
>
>
>
>template <typename T>
>struct alignment_of<T&>
> : public alignment_of<T*>
>{
>};
># 109 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
>template<> struct alignment_of<void> : public ::boost::integral_constant<std::size_t,0> { public: };
>
>template<> struct alignment_of<void const> : public ::boost::integral_constant<std::size_t,0> { public: };
>template<> struct alignment_of<void volatile> : public ::boost::integral_constant<std::size_t,0> { public: };
>template<> struct alignment_of<void const volatile> : public ::boost::integral_constant<std::size_t,0> { public: };
>
>
>}
># 125 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/size_t_trait_undef.hpp" 1 3 4
># 126 "/usr/include/boost/type_traits/alignment_of.hpp" 2 3 4
># 21 "/usr/include/boost/aligned_storage.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/type_with_alignment.hpp" 1 3 4
># 12 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/list/for_each_i.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/type_with_alignment.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/tuple/to_list.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/type_with_alignment.hpp" 2 3 4
>
># 1 "/usr/include/boost/preprocessor/list/transform.hpp" 1 3 4
># 16 "/usr/include/boost/type_traits/type_with_alignment.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/list/append.hpp" 1 3 4
># 17 "/usr/include/boost/type_traits/type_with_alignment.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 24 "/usr/include/boost/type_traits/type_with_alignment.hpp" 2 3 4
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 26 "/usr/include/boost/type_traits/type_with_alignment.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost {
>
>
>
>namespace detail {
>
>class alignment_dummy;
>typedef void (*function_ptr)();
>typedef int (alignment_dummy::*member_ptr);
>typedef int (alignment_dummy::*member_function_ptr)();
># 101 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
>template <bool found, std::size_t target, class TestType>
>struct lower_alignment_helper
>{
> typedef char type;
> enum { value = true };
>};
>
>template <std::size_t target, class TestType>
>struct lower_alignment_helper<false,target,TestType>
>{
> enum { value = (alignment_of<TestType>::value == target) };
> typedef typename mpl::if_c<value, TestType, char>::type type;
>};
># 127 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
>template <typename T>
>struct has_one_T
>{
> T data;
>};
>
>template <std::size_t target>
>union lower_alignment
>{
> enum { found0 = false };
>
> typename lower_alignment_helper< found0,target,char >::type t0; enum { found1 = lower_alignment_helper<found0,target,char >::value }; typename lower_alignment_helper< found1,target,short >::type t1; enum { found2 = lower_alignment_helper<found1,target,short >::value }; typename lower_alignment_helper< found2,target,int >::type t2; enum { found3 = lower_alignment_helper<found2,target,int >::value }; typename lower_alignment_helper< found3,target,long >::type t3; enum { found4 = lower_alignment_helper<found3,target,long >::value }; typename lower_alignment_helper< found4,target,::boost::long_long_type >::type t4; enum { found5 = lower_alignment_helper<found4,target,::boost::long_long_type >::value }; typename lower_alignment_helper< found5,target,float >::type t5; enum { found6 = lower_alignment_helper<found5,target,float >::value }; typename lower_alignment_helper< found6,target,double >::type t6; enum { found7 = lower_alignment_helper<found6,target,double >::value }; typename lower_alignment_helper< found7,target,long double >::type t7; enum { found8 = lower_alignment_helper<found7,target,long double >::value }; typename lower_alignment_helper< found8,target,void* >::type t8; enum { found9 = lower_alignment_helper<found8,target,void* >::value }; typename lower_alignment_helper< found9,target,function_ptr >::type t9; enum { found10 = lower_alignment_helper<found9,target,function_ptr >::value }; typename lower_alignment_helper< found10,target,member_ptr >::type t10; enum { found11 = lower_alignment_helper<found10,target,member_ptr >::value }; typename lower_alignment_helper< found11,target,member_function_ptr >::type t11; enum { found12 = lower_alignment_helper<found11,target,member_function_ptr >::value }; typename lower_alignment_helper< found12,target,boost::detail::has_one_T< char > >::type t12; enum { found13 = lower_alignment_helper<found12,target,boost::detail::has_one_T< char > >::value }; typename lower_alignment_helper< found13,target,boost::detail::has_one_T< short > >::type t13; enum { found14 = lower_alignment_helper<found13,target,boost::detail::has_one_T< short > >::value }; typename lower_alignment_helper< found14,target,boost::detail::has_one_T< int > >::type t14; enum { found15 = lower_alignment_helper<found14,target,boost::detail::has_one_T< int > >::value }; typename lower_alignment_helper< found15,target,boost::detail::has_one_T< long > >::type t15; enum { found16 = lower_alignment_helper<found15,target,boost::detail::has_one_T< long > >::value }; typename lower_alignment_helper< found16,target,boost::detail::has_one_T< ::boost::long_long_type > >::type t16; enum { found17 = lower_alignment_helper<found16,target,boost::detail::has_one_T< ::boost::long_long_type > >::value }; typename lower_alignment_helper< found17,target,boost::detail::has_one_T< float > >::type t17; enum { found18 = lower_alignment_helper<found17,target,boost::detail::has_one_T< float > >::value }; typename lower_alignment_helper< found18,target,boost::detail::has_one_T< double > >::type t18; enum { found19 = lower_alignment_helper<found18,target,boost::detail::has_one_T< double > >::value }; typename lower_alignment_helper< found19,target,boost::detail::has_one_T< long double > >::type t19; enum { found20 = lower_alignment_helper<found19,target,boost::detail::has_one_T< long double > >::value }; typename lower_alignment_helper< found20,target,boost::detail::has_one_T< void* > >::type t20; enum { found21 = lower_alignment_helper<found20,target,boost::detail::has_one_T< void* > >::value }; typename lower_alignment_helper< found21,target,boost::detail::has_one_T< function_ptr > >::type t21; enum { found22 = lower_alignment_helper<found21,target,boost::detail::has_one_T< function_ptr > >::value }; typename lower_alignment_helper< found22,target,boost::detail::has_one_T< member_ptr > >::type t22; enum { found23 = lower_alignment_helper<found22,target,boost::detail::has_one_T< member_ptr > >::value }; typename lower_alignment_helper< found23,target,boost::detail::has_one_T< member_function_ptr > >::type t23; enum { found24 = lower_alignment_helper<found23,target,boost::detail::has_one_T< member_function_ptr > >::value };
>
>
>
>
>};
>
>union max_align
>{
> char t0; short t1; int t2; long t3; ::boost::long_long_type t4; float t5; double t6; long double t7; void* t8; function_ptr t9; member_ptr t10; member_function_ptr t11; boost::detail::has_one_T< char > t12; boost::detail::has_one_T< short > t13; boost::detail::has_one_T< int > t14; boost::detail::has_one_T< long > t15; boost::detail::has_one_T< ::boost::long_long_type > t16; boost::detail::has_one_T< float > t17; boost::detail::has_one_T< double > t18; boost::detail::has_one_T< long double > t19; boost::detail::has_one_T< void* > t20; boost::detail::has_one_T< function_ptr > t21; boost::detail::has_one_T< member_ptr > t22; boost::detail::has_one_T< member_function_ptr > t23;
>
>
>
>
>};
># 161 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
>template<std::size_t TAlign, std::size_t Align>
>struct is_aligned
>{
> static const bool value = (TAlign >= Align) & (TAlign % Align == 0)
>
> ;
>};
># 180 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
>}
>
>
>template<std::size_t Align>
>struct is_pod< ::boost::detail::lower_alignment<Align> >
>{
> static const std::size_t value = true;
>};
>
>
>
>
>namespace detail{
>
>template <std::size_t Align>
>class type_with_alignment_imp
>{
> typedef ::boost::detail::lower_alignment<Align> t1;
> typedef typename mpl::if_c<
> ::boost::detail::is_aligned< ::boost::alignment_of<t1>::value,Align >::value
> , t1
> , ::boost::detail::max_align
> >::type align_t;
>
> static const std::size_t found = alignment_of<align_t>::value;
>
> static_assert(found >= Align, "found >= Align");
> static_assert(found % Align == 0, "found % Align == 0");
>
> public:
> typedef align_t type;
>};
>
>}
>
>template <std::size_t Align>
>class type_with_alignment
> : public ::boost::detail::type_with_alignment_imp<Align>
>{
>};
>
>
>namespace align {
>struct __attribute__((__aligned__(2))) a2 {};
>struct __attribute__((__aligned__(4))) a4 {};
>struct __attribute__((__aligned__(8))) a8 {};
>struct __attribute__((__aligned__(16))) a16 {};
>struct __attribute__((__aligned__(32))) a32 {};
>struct __attribute__((__aligned__(64))) a64 {};
>struct __attribute__((__aligned__(128))) a128 {};
>}
>
>template<> class type_with_alignment<1> { public: typedef char type; };
>template<> class type_with_alignment<2> { public: typedef align::a2 type; };
>template<> class type_with_alignment<4> { public: typedef align::a4 type; };
>template<> class type_with_alignment<8> { public: typedef align::a8 type; };
>template<> class type_with_alignment<16> { public: typedef align::a16 type; };
>template<> class type_with_alignment<32> { public: typedef align::a32 type; };
>template<> class type_with_alignment<64> { public: typedef align::a64 type; };
>template<> class type_with_alignment<128> { public: typedef align::a128 type; };
>
>namespace detail {
>template<> struct is_pod_impl< ::boost::align::a2 > { public: static const bool value = (true); };
>template<> struct is_pod_impl< ::boost::align::a4 > { public: static const bool value = (true); };
>template<> struct is_pod_impl< ::boost::align::a8 > { public: static const bool value = (true); };
>template<> struct is_pod_impl< ::boost::align::a16 > { public: static const bool value = (true); };
>template<> struct is_pod_impl< ::boost::align::a32 > { public: static const bool value = (true); };
>template<> struct is_pod_impl< ::boost::align::a64 > { public: static const bool value = (true); };
>template<> struct is_pod_impl< ::boost::align::a128 > { public: static const bool value = (true); };
>}
># 389 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 396 "/usr/include/boost/type_traits/type_with_alignment.hpp" 2 3 4
># 22 "/usr/include/boost/aligned_storage.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 28 "/usr/include/boost/aligned_storage.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail { namespace aligned_storage {
>
>static const std::size_t alignment_of_max_align = ::boost::alignment_of<max_align>::value
>
>
> ;
>
>
>
>
>template <
> std::size_t size_
> , std::size_t alignment_
>>
>struct aligned_storage_imp
>{
> union data_t
> {
> char buf[size_];
>
> typename mpl::eval_if_c<
> alignment_ == std::size_t(-1)
> , mpl::identity<detail::max_align>
> , type_with_alignment<alignment_>
> >::type align_;
> } data_;
> void* address() const { return const_cast<aligned_storage_imp*>(this); }
>};
>
>template< std::size_t alignment_ >
>struct aligned_storage_imp<0u,alignment_>
>{
>
> void* address() const { return 0; }
>};
>
>}}
>
>template <
> std::size_t size_
> , std::size_t alignment_ = std::size_t(-1)
>>
>class aligned_storage :
>
> private
>
>
>
> detail::aligned_storage::aligned_storage_imp<size_, alignment_>
>{
>
>public:
>
> typedef detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;
>
> static const std::size_t size = size_
>
>
> ;
> static const std::size_t alignment = ( alignment_ == std::size_t(-1) ? ::boost::detail::aligned_storage::alignment_of_max_align : alignment_ )
>
>
>
>
>
>
> ;
>
>
>
>
>
>
>private:
>
> aligned_storage(const aligned_storage&);
> aligned_storage& operator=(const aligned_storage&);
># 118 "/usr/include/boost/aligned_storage.hpp" 3 4
>public:
>
> aligned_storage()
> {
> }
>
> ~aligned_storage()
> {
> }
>
>public:
>
> void* address()
> {
> return static_cast<type*>(this)->address();
> }
>
>
>
> const void* address() const
> {
> return static_cast<const type*>(this)->address();
> }
>
>
>
>
>
>
>
>};
># 168 "/usr/include/boost/aligned_storage.hpp" 3 4
>template <std::size_t size_, std::size_t alignment_>
>struct is_pod<boost::detail::aligned_storage::aligned_storage_imp<size_,alignment_> >
> : public ::boost::integral_constant<bool,true>
>{
> 
>};
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 180 "/usr/include/boost/aligned_storage.hpp" 2 3 4
># 12 "/usr/include/boost/type_traits/aligned_storage.hpp" 2 3 4
># 21 "/usr/include/boost/type_traits.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/common_type.hpp" 1 3 4
># 53 "/usr/include/boost/type_traits/common_type.hpp" 3 4
># 1 "/usr/include/boost/utility/declval.hpp" 1 3 4
># 38 "/usr/include/boost/utility/declval.hpp" 3 4
>namespace boost {
>
>
> template <typename T>
> typename add_rvalue_reference<T>::type declval() noexcept;
>
>
>
>
>}
># 54 "/usr/include/boost/type_traits/common_type.hpp" 2 3 4
># 65 "/usr/include/boost/type_traits/common_type.hpp" 3 4
>namespace boost {
>
>
>
> template<typename... T>
> struct common_type;
># 82 "/usr/include/boost/type_traits/common_type.hpp" 3 4
> template<typename T>
>
> struct common_type<T>
>
>
>
>
> {
> static_assert(sizeof(T) > 0,"must be complete type");
> public:
> typedef T type;
> };
>
>
>namespace type_traits_detail {
>
> template <class T, class U>
> struct common_type_2
> {
> private:
> static_assert(sizeof(T) > 0,"must be complete type");
> static_assert(sizeof(U) > 0,"must be complete type");
> static bool declval_bool();
> static typename add_rvalue_reference<T>::type declval_T();
> static typename add_rvalue_reference::type declval_U();
> static typename add_rvalue_reference<bool>::type declval_b();
>
>
> public:
> typedef decltype(declval<bool>() ? declval<T>() : declval()) type;
># 127 "/usr/include/boost/type_traits/common_type.hpp" 3 4
> };
>
> template <class T>
> struct common_type_2<T, T>
> {
> typedef T type;
> };
> }
>
>
> template <class T, class U>
> struct common_type<T, U>
>
>
>
>
> : public type_traits_detail::common_type_2<T,U>
> { };
>
>
>
>
> template<typename T, typename U, typename... V>
> struct common_type<T, U, V...> {
> public:
> typedef typename common_type<typename common_type<T, U>::type, V...>::type type;
> };
>
>}
># 23 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/conditional.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/conditional.hpp" 3 4
>namespace boost {
>
>template <bool b, class T, class U>
>struct conditional : public mpl::if_c<b, T, U>
>{
>};
>
>}
># 24 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/decay.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/decay.hpp" 3 4
># 1 "/usr/include/boost/type_traits/remove_bounds.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/remove_bounds.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 14 "/usr/include/boost/type_traits/remove_bounds.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 22 "/usr/include/boost/type_traits/remove_bounds.hpp" 2 3 4
>
>
>
>namespace boost {
>
>template< typename T > struct remove_bounds { public: typedef T type; };
>
>
>template< typename T, std::size_t N > struct remove_bounds<T[N]> { public: typedef T type; };
>template< typename T, std::size_t N > struct remove_bounds<T const[N]> { public: typedef T const type; };
>template< typename T, std::size_t N > struct remove_bounds<T volatile[N]> { public: typedef T volatile type; };
>template< typename T, std::size_t N > struct remove_bounds<T const volatile[N]> { public: typedef T const volatile type; };
>
>template< typename T > struct remove_bounds<T[]> { public: typedef T type; };
>template< typename T > struct remove_bounds<T const[]> { public: typedef T const type; };
>template< typename T > struct remove_bounds<T volatile[]> { public: typedef T volatile type; };
>template< typename T > struct remove_bounds<T const volatile[]> { public: typedef T const volatile type; };
>
>
>
>}
>
>
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 47 "/usr/include/boost/type_traits/remove_bounds.hpp" 2 3 4
># 16 "/usr/include/boost/type_traits/decay.hpp" 2 3 4
>
>
>
>
>
>namespace boost
>{
>
> template< class T >
> struct decay
> {
> private:
> typedef typename remove_reference<T>::type Ty;
> public:
> typedef typename mpl::eval_if<
> is_array<Ty>,
> mpl::identity<typename remove_bounds<Ty>::type*>,
> typename mpl::eval_if<
> is_function<Ty>,
> add_pointer<Ty>,
> mpl::identity<Ty>
> >
> >::type type;
> };
>
>}
># 25 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/extent.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/extent.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 2 3 4
># 15 "/usr/include/boost/type_traits/extent.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail{
># 29 "/usr/include/boost/type_traits/extent.hpp" 3 4
>template <class T, std::size_t N>
>struct extent_imp
>{
> static const std::size_t value = 0;
>};
>
>template <class T, std::size_t R, std::size_t N>
>struct extent_imp<T[R], N>
>{
> static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
>};
>
>template <class T, std::size_t R, std::size_t N>
>struct extent_imp<T const[R], N>
>{
> static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
>};
>
>template <class T, std::size_t R, std::size_t N>
>struct extent_imp<T volatile[R], N>
>{
> static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
>};
>
>template <class T, std::size_t R, std::size_t N>
>struct extent_imp<T const volatile[R], N>
>{
> static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
>};
>
>template <class T, std::size_t R>
>struct extent_imp<T[R],0>
>{
> static const std::size_t value = R;
>};
>
>template <class T, std::size_t R>
>struct extent_imp<T const[R], 0>
>{
> static const std::size_t value = R;
>};
>
>template <class T, std::size_t R>
>struct extent_imp<T volatile[R], 0>
>{
> static const std::size_t value = R;
>};
>
>template <class T, std::size_t R>
>struct extent_imp<T const volatile[R], 0>
>{
> static const std::size_t value = R;
>};
>
>
>template <class T, std::size_t N>
>struct extent_imp<T[], N>
>{
> static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
>};
>template <class T, std::size_t N>
>struct extent_imp<T const[], N>
>{
> static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
>};
>template <class T, std::size_t N>
>struct extent_imp<T volatile[], N>
>{
> static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
>};
>template <class T, std::size_t N>
>struct extent_imp<T const volatile[], N>
>{
> static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
>};
>template <class T>
>struct extent_imp<T[], 0>
>{
> static const std::size_t value = 0;
>};
>template <class T>
>struct extent_imp<T const[], 0>
>{
> static const std::size_t value = 0;
>};
>template <class T>
>struct extent_imp<T volatile[], 0>
>{
> static const std::size_t value = 0;
>};
>template <class T>
>struct extent_imp<T const volatile[], 0>
>{
> static const std::size_t value = 0;
>};
>
>
>
>
>}
>
>template <class T, std::size_t N = 0>
>struct extent
> : public ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value>
>{
>
>
>
>
> 
>};
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/size_t_trait_undef.hpp" 1 3 4
># 144 "/usr/include/boost/type_traits/extent.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/floating_point_promotion.hpp" 1 3 4
># 21 "/usr/include/boost/type_traits/floating_point_promotion.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 22 "/usr/include/boost/type_traits/floating_point_promotion.hpp" 2 3 4
>
>namespace boost {
>
>namespace type_traits { namespace detail {
>
>
>
>template<class T>
>struct floating_point_promotion
>{
> typedef T type;
>};
>
>template<>
>struct floating_point_promotion<float>
>{
> typedef double type;
>};
>
>template<>
>struct floating_point_promotion<float const>
>{
> typedef double const type;
>};
>
>template<>
>struct floating_point_promotion<float volatile>
>{
> typedef double volatile type;
>};
>
>template<>
>struct floating_point_promotion<float const volatile>
>{
> typedef double const volatile type;
>};
># 78 "/usr/include/boost/type_traits/floating_point_promotion.hpp" 3 4
>} }
>
>template< typename T > struct floating_point_promotion { public: typedef typename boost::type_traits::detail::floating_point_promotion<T>::type type; };
>
>
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 89 "/usr/include/boost/type_traits/floating_point_promotion.hpp" 2 3 4
># 27 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/function_traits.hpp" 1 3 4
># 16 "/usr/include/boost/type_traits/function_traits.hpp" 3 4
>namespace boost {
>
>
>namespace detail {
>
>template<typename Function> struct function_traits_helper;
>
>template<typename R>
>struct function_traits_helper<R (*)(void)>
>{
> static const unsigned arity = 0;
> typedef R result_type;
>};
>
>template<typename R, typename T1>
>struct function_traits_helper<R (*)(T1)>
>{
> static const unsigned arity = 1;
> typedef R result_type;
> typedef T1 arg1_type;
> typedef T1 argument_type;
>};
>
>template<typename R, typename T1, typename T2>
>struct function_traits_helper<R (*)(T1, T2)>
>{
> static const unsigned arity = 2;
> typedef R result_type;
> typedef T1 arg1_type;
> typedef T2 arg2_type;
> typedef T1 first_argument_type;
> typedef T2 second_argument_type;
>};
>
>template<typename R, typename T1, typename T2, typename T3>
>struct function_traits_helper<R (*)(T1, T2, T3)>
>{
> static const unsigned arity = 3;
> typedef R result_type;
> typedef T1 arg1_type;
> typedef T2 arg2_type;
> typedef T3 arg3_type;
>};
>
>template<typename R, typename T1, typename T2, typename T3, typename T4>
>struct function_traits_helper<R (*)(T1, T2, T3, T4)>
>{
> static const unsigned arity = 4;
> typedef R result_type;
> typedef T1 arg1_type;
> typedef T2 arg2_type;
> typedef T3 arg3_type;
> typedef T4 arg4_type;
>};
>
>template<typename R, typename T1, typename T2, typename T3, typename T4,
> typename T5>
>struct function_traits_helper<R (*)(T1, T2, T3, T4, T5)>
>{
> static const unsigned arity = 5;
> typedef R result_type;
> typedef T1 arg1_type;
> typedef T2 arg2_type;
> typedef T3 arg3_type;
> typedef T4 arg4_type;
> typedef T5 arg5_type;
>};
>
>template<typename R, typename T1, typename T2, typename T3, typename T4,
> typename T5, typename T6>
>struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6)>
>{
> static const unsigned arity = 6;
> typedef R result_type;
> typedef T1 arg1_type;
> typedef T2 arg2_type;
> typedef T3 arg3_type;
> typedef T4 arg4_type;
> typedef T5 arg5_type;
> typedef T6 arg6_type;
>};
>
>template<typename R, typename T1, typename T2, typename T3, typename T4,
> typename T5, typename T6, typename T7>
>struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7)>
>{
> static const unsigned arity = 7;
> typedef R result_type;
> typedef T1 arg1_type;
> typedef T2 arg2_type;
> typedef T3 arg3_type;
> typedef T4 arg4_type;
> typedef T5 arg5_type;
> typedef T6 arg6_type;
> typedef T7 arg7_type;
>};
>
>template<typename R, typename T1, typename T2, typename T3, typename T4,
> typename T5, typename T6, typename T7, typename T8>
>struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8)>
>{
> static const unsigned arity = 8;
> typedef R result_type;
> typedef T1 arg1_type;
> typedef T2 arg2_type;
> typedef T3 arg3_type;
> typedef T4 arg4_type;
> typedef T5 arg5_type;
> typedef T6 arg6_type;
> typedef T7 arg7_type;
> typedef T8 arg8_type;
>};
>
>template<typename R, typename T1, typename T2, typename T3, typename T4,
> typename T5, typename T6, typename T7, typename T8, typename T9>
>struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
>{
> static const unsigned arity = 9;
> typedef R result_type;
> typedef T1 arg1_type;
> typedef T2 arg2_type;
> typedef T3 arg3_type;
> typedef T4 arg4_type;
> typedef T5 arg5_type;
> typedef T6 arg6_type;
> typedef T7 arg7_type;
> typedef T8 arg8_type;
> typedef T9 arg9_type;
>};
>
>template<typename R, typename T1, typename T2, typename T3, typename T4,
> typename T5, typename T6, typename T7, typename T8, typename T9,
> typename T10>
>struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
>{
> static const unsigned arity = 10;
> typedef R result_type;
> typedef T1 arg1_type;
> typedef T2 arg2_type;
> typedef T3 arg3_type;
> typedef T4 arg4_type;
> typedef T5 arg5_type;
> typedef T6 arg6_type;
> typedef T7 arg7_type;
> typedef T8 arg8_type;
> typedef T9 arg9_type;
> typedef T10 arg10_type;
>};
>
>}
>
>template<typename Function>
>struct function_traits :
> public boost::detail::function_traits_helper<typename boost::add_pointer<Function>::type>
>{
>};
># 234 "/usr/include/boost/type_traits/function_traits.hpp" 3 4
>}
># 28 "/usr/include/boost/type_traits.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/has_new_operator.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/has_new_operator.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 14 "/usr/include/boost/type_traits/has_new_operator.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 20 "/usr/include/boost/type_traits/has_new_operator.hpp" 2 3 4
>
>namespace boost {
>namespace detail {
> template <class U, U x>
> struct test;
>
> template <typename T>
> struct has_new_operator_impl {
> template<class U>
> static type_traits::yes_type check_sig1(
> U*,
> test<
> void *(*)(std::size_t),
> &U::operator new
> >* = __null
> );
> template<class U>
> static type_traits::no_type check_sig1(...);
>
> template<class U>
> static type_traits::yes_type check_sig2(
> U*,
> test<
> void *(*)(std::size_t, const std::nothrow_t&),
> &U::operator new
> >* = __null
> );
> template<class U>
> static type_traits::no_type check_sig2(...);
>
> template<class U>
> static type_traits::yes_type check_sig3(
> U*,
> test<
> void *(*)(std::size_t, void*),
> &U::operator new
> >* = __null
> );
> template<class U>
> static type_traits::no_type check_sig3(...);
>
>
> template<class U>
> static type_traits::yes_type check_sig4(
> U*,
> test<
> void *(*)(std::size_t),
> &U::operator new[]
> >* = __null
> );
> template<class U>
> static type_traits::no_type check_sig4(...);
>
> template<class U>
> static type_traits::yes_type check_sig5(
> U*,
> test<
> void *(*)(std::size_t, const std::nothrow_t&),
> &U::operator new[]
> >* = __null
> );
> template<class U>
> static type_traits::no_type check_sig5(...);
>
> template<class U>
> static type_traits::yes_type check_sig6(
> U*,
> test<
> void *(*)(std::size_t, void*),
> &U::operator new[]
> >* = __null
> );
> template<class U>
> static type_traits::no_type check_sig6(...);
>
>
>
>
> static const unsigned s1 = sizeof(has_new_operator_impl<T>::template check_sig1<T>(0));
> static const unsigned s2 = sizeof(has_new_operator_impl<T>::template check_sig2<T>(0));
> static const unsigned s3 = sizeof(has_new_operator_impl<T>::template check_sig3<T>(0));
> static const unsigned s4 = sizeof(has_new_operator_impl<T>::template check_sig4<T>(0));
> static const unsigned s5 = sizeof(has_new_operator_impl<T>::template check_sig5<T>(0));
> static const unsigned s6 = sizeof(has_new_operator_impl<T>::template check_sig6<T>(0));
># 121 "/usr/include/boost/type_traits/has_new_operator.hpp" 3 4
> static const bool value = (::boost::type_traits::ice_or< (s1 == sizeof(type_traits::yes_type)), (s2 == sizeof(type_traits::yes_type)), (s3 == sizeof(type_traits::yes_type)), (s4 == sizeof(type_traits::yes_type)), (s5 == sizeof(type_traits::yes_type)), (s6 == sizeof(type_traits::yes_type)) >::value)
># 130 "/usr/include/boost/type_traits/has_new_operator.hpp" 3 4
> ;
> };
>}
>
>template< typename T > struct has_new_operator : public ::boost::integral_constant<bool,::boost::detail::has_new_operator_impl<T>::value> { public: };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 139 "/usr/include/boost/type_traits/has_new_operator.hpp" 2 3 4
># 30 "/usr/include/boost/type_traits.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/has_nothrow_assign.hpp" 1 3 4
># 12 "/usr/include/boost/type_traits/has_nothrow_assign.hpp" 3 4
># 1 "/usr/include/boost/type_traits/has_trivial_assign.hpp" 1 3 4
># 22 "/usr/include/boost/type_traits/has_trivial_assign.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 23 "/usr/include/boost/type_traits/has_trivial_assign.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
>
>template <typename T>
>struct has_trivial_assign_impl
>{
>
> static const bool value = ((__has_trivial_assign(T) ) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<T>::value);
># 41 "/usr/include/boost/type_traits/has_trivial_assign.hpp" 3 4
>};
>
>}
>
>template< typename T > struct has_trivial_assign : public ::boost::integral_constant<bool,::boost::detail::has_trivial_assign_impl<T>::value> { public: };
>template<> struct has_trivial_assign< void > : public ::boost::integral_constant<bool,false> { public: };
>
>template<> struct has_trivial_assign< void const > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_trivial_assign< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_trivial_assign< void volatile > : public ::boost::integral_constant<bool,false> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 56 "/usr/include/boost/type_traits/has_trivial_assign.hpp" 2 3 4
># 13 "/usr/include/boost/type_traits/has_nothrow_assign.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 16 "/usr/include/boost/type_traits/has_nothrow_assign.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail{
>
>template <class T>
>struct has_nothrow_assign_imp{
>
>
>
> static const bool value = ((__has_nothrow_assign(T) ) && !is_volatile<T>::value && !is_const<T>::value);
>
>};
>
>}
>
>template< typename T > struct has_nothrow_assign : public ::boost::integral_constant<bool,::boost::detail::has_nothrow_assign_imp<T>::value> { public: };
>template<> struct has_nothrow_assign< void > : public ::boost::integral_constant<bool,false> { public: };
>
>template<> struct has_nothrow_assign< void const > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_nothrow_assign< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_nothrow_assign< void volatile > : public ::boost::integral_constant<bool,false> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 43 "/usr/include/boost/type_traits/has_nothrow_assign.hpp" 2 3 4
># 32 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_nothrow_constructor.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/has_nothrow_constructor.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 16 "/usr/include/boost/type_traits/has_nothrow_constructor.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail{
>
>template <class T>
>struct has_nothrow_constructor_imp{
>
> static const bool value = (__has_nothrow_constructor(T) );
>
>
>
>};
>
>}
>
>template< typename T > struct has_nothrow_constructor : public ::boost::integral_constant<bool,::boost::detail::has_nothrow_constructor_imp<T>::value> { public: };
>template< typename T > struct has_nothrow_default_constructor : public ::boost::integral_constant<bool,::boost::detail::has_nothrow_constructor_imp<T>::value> { public: };
>
>template<> struct has_nothrow_constructor< void > : public ::boost::integral_constant<bool,false> { public: };
>
>template<> struct has_nothrow_constructor< void const > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_nothrow_constructor< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_nothrow_constructor< void volatile > : public ::boost::integral_constant<bool,false> { public: };
>
>
>template<> struct has_nothrow_default_constructor< void > : public ::boost::integral_constant<bool,false> { public: };
>
>template<> struct has_nothrow_default_constructor< void const > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_nothrow_default_constructor< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_nothrow_default_constructor< void volatile > : public ::boost::integral_constant<bool,false> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 52 "/usr/include/boost/type_traits/has_nothrow_constructor.hpp" 2 3 4
># 33 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_nothrow_copy.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/has_nothrow_copy.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 16 "/usr/include/boost/type_traits/has_nothrow_copy.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail{
>
>template <class T>
>struct has_nothrow_copy_imp{
>
> static const bool value = ((__has_nothrow_copy(T) ) && !is_volatile<T>::value && !is_reference<T>::value);
>
>
>
>};
>
>}
>
>template< typename T > struct has_nothrow_copy : public ::boost::integral_constant<bool,::boost::detail::has_nothrow_copy_imp<T>::value> { public: };
>template< typename T > struct has_nothrow_copy_constructor : public ::boost::integral_constant<bool,::boost::detail::has_nothrow_copy_imp<T>::value> { public: };
>
>template<> struct has_nothrow_copy< void > : public ::boost::integral_constant<bool,false> { public: };
>
>template<> struct has_nothrow_copy< void const > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_nothrow_copy< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_nothrow_copy< void volatile > : public ::boost::integral_constant<bool,false> { public: };
>
>
>template<> struct has_nothrow_copy_constructor< void > : public ::boost::integral_constant<bool,false> { public: };
>
>template<> struct has_nothrow_copy_constructor< void const > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_nothrow_copy_constructor< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_nothrow_copy_constructor< void volatile > : public ::boost::integral_constant<bool,false> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 52 "/usr/include/boost/type_traits/has_nothrow_copy.hpp" 2 3 4
># 34 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_nothrow_destructor.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/has_nothrow_destructor.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 16 "/usr/include/boost/type_traits/has_nothrow_destructor.hpp" 2 3 4
>
>namespace boost {
>
>template< typename T > struct has_nothrow_destructor : public ::boost::integral_constant<bool,::boost::has_trivial_destructor<T>::value> { public: };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 24 "/usr/include/boost/type_traits/has_nothrow_destructor.hpp" 2 3 4
># 35 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_operator.hpp" 1 3 4
># 12 "/usr/include/boost/type_traits/has_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/has_bit_and.hpp" 1 3 4
># 43 "/usr/include/boost/type_traits/has_bit_and.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 12 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_base_of.hpp" 1 3 4
># 12 "/usr/include/boost/type_traits/is_base_of.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 1 3 4
># 24 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 25 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
># 222 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 3 4
>template <typename B, typename D>
>struct is_base_and_derived_impl
>{
> typedef typename remove_cv::type ncvB;
> typedef typename remove_cv<D>::type ncvD;
>
> static const bool value = ((__is_base_of(B,D) && !is_same<B,D>::value) && ! ::boost::is_same<ncvB,ncvD>::value);
>};
>
>}
>
>template< typename Base, typename Derived > struct is_base_and_derived : public ::boost::integral_constant<bool,(::boost::detail::is_base_and_derived_impl<Base,Derived>::value)> { public: };
>
>
>
>
>
>
>
>template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived > : public ::boost::integral_constant<bool,false> { public: };
>template< typename Base, typename Derived > struct is_base_and_derived< Base,Derived& > : public ::boost::integral_constant<bool,false> { public: };
>template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived& > : public ::boost::integral_constant<bool,false> { public: };
>
>
>
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 253 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4
># 13 "/usr/include/boost/type_traits/is_base_of.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 20 "/usr/include/boost/type_traits/is_base_of.hpp" 2 3 4
>
>namespace boost {
>
> namespace detail{
> template <class B, class D>
> struct is_base_of_imp
> {
> typedef typename remove_cv::type ncvB;
> typedef typename remove_cv<D>::type ncvD;
> static const bool value = (::boost::type_traits::ice_or< (::boost::detail::is_base_and_derived_impl<ncvB,ncvD>::value), (::boost::type_traits::ice_and< ::boost::is_same<ncvB,ncvD>::value, ::boost::is_class<ncvB>::value>::value)>::value)
>
> ;
> };
> }
>
>template< typename Base, typename Derived > struct is_base_of : public ::boost::integral_constant<bool,(::boost::detail::is_base_of_imp<Base, Derived>::value)> { public: };
>
>
>
>
>
>
>template< typename Base, typename Derived > struct is_base_of< Base&,Derived > : public ::boost::integral_constant<bool,false> { public: };
>template< typename Base, typename Derived > struct is_base_of< Base,Derived& > : public ::boost::integral_constant<bool,false> { public: };
>template< typename Base, typename Derived > struct is_base_of< Base&,Derived& > : public ::boost::integral_constant<bool,false> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 50 "/usr/include/boost/type_traits/is_base_of.hpp" 2 3 4
># 13 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/type_traits/is_fundamental.hpp" 1 3 4
># 17 "/usr/include/boost/type_traits/is_fundamental.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 18 "/usr/include/boost/type_traits/is_fundamental.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
>
>template <typename T>
>struct is_fundamental_impl
> : public ::boost::type_traits::ice_or<
> ::boost::is_arithmetic<T>::value
> , ::boost::is_void<T>::value
> >
>{
>};
>
>}
>
>
>
>
>
>template< typename T > struct is_fundamental : public ::boost::integral_constant<bool,::boost::detail::is_fundamental_impl<T>::value> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 44 "/usr/include/boost/type_traits/is_fundamental.hpp" 2 3 4
># 16 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_bit_and_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator & (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() & make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() & make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() & make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_or< ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_bit_and_impl::dont_care > struct has_bit_and : public ::boost::integral_constant<bool,(::boost::detail::has_bit_and_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 44 "/usr/include/boost/type_traits/has_bit_and.hpp" 2 3 4
># 13 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_bit_and_assign.hpp" 1 3 4
># 49 "/usr/include/boost/type_traits/has_bit_and_assign.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_bit_and_assign_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator &= (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() &= make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() &= make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() &= make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_or< ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_bit_and_assign_impl::dont_care > struct has_bit_and_assign : public ::boost::integral_constant<bool,(::boost::detail::has_bit_and_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 50 "/usr/include/boost/type_traits/has_bit_and_assign.hpp" 2 3 4
># 14 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_bit_or.hpp" 1 3 4
># 43 "/usr/include/boost/type_traits/has_bit_or.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_bit_or_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator | (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() | make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() | make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() | make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_or< ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_bit_or_impl::dont_care > struct has_bit_or : public ::boost::integral_constant<bool,(::boost::detail::has_bit_or_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 44 "/usr/include/boost/type_traits/has_bit_or.hpp" 2 3 4
># 15 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_bit_or_assign.hpp" 1 3 4
># 49 "/usr/include/boost/type_traits/has_bit_or_assign.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_bit_or_assign_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator |= (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() |= make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() |= make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() |= make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_or< ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_bit_or_assign_impl::dont_care > struct has_bit_or_assign : public ::boost::integral_constant<bool,(::boost::detail::has_bit_or_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 50 "/usr/include/boost/type_traits/has_bit_or_assign.hpp" 2 3 4
># 16 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_bit_xor.hpp" 1 3 4
># 43 "/usr/include/boost/type_traits/has_bit_xor.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_bit_xor_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator ^ (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() ^ make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() ^ make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() ^ make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_or< ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_bit_xor_impl::dont_care > struct has_bit_xor : public ::boost::integral_constant<bool,(::boost::detail::has_bit_xor_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 44 "/usr/include/boost/type_traits/has_bit_xor.hpp" 2 3 4
># 17 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_bit_xor_assign.hpp" 1 3 4
># 49 "/usr/include/boost/type_traits/has_bit_xor_assign.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_bit_xor_assign_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator ^= (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() ^= make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() ^= make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() ^= make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_or< ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_bit_xor_assign_impl::dont_care > struct has_bit_xor_assign : public ::boost::integral_constant<bool,(::boost::detail::has_bit_xor_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 50 "/usr/include/boost/type_traits/has_bit_xor_assign.hpp" 2 3 4
># 18 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_complement.hpp" 1 3 4
># 26 "/usr/include/boost/type_traits/has_complement.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 1 3 4
># 23 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 24 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3 4
># 34 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
> 
># 35 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_complement_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator ~ (const any&);
># 76 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((~ make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(~ make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 144 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((~ make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 163 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>template < typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Ret >
>struct trait_impl1 < void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Rhs, typename Ret=::boost::detail::has_complement_impl::dont_care > struct has_complement : public ::boost::integral_constant<bool,(::boost::detail::has_complement_impl::trait_impl < Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 210 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
># 27 "/usr/include/boost/type_traits/has_complement.hpp" 2 3 4
># 19 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_dereference.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/has_dereference.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 1 3 4
># 23 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 24 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3 4
># 34 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
> 
># 35 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_dereference_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator * (const any&);
># 76 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((* make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(* make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 144 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((* make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 163 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>template < typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Ret >
>struct trait_impl1 < void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_void< Rhs_noptr >::value >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Rhs, typename Ret=::boost::detail::has_dereference_impl::dont_care > struct has_dereference : public ::boost::integral_constant<bool,(::boost::detail::has_dereference_impl::trait_impl < Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 210 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
># 26 "/usr/include/boost/type_traits/has_dereference.hpp" 2 3 4
># 20 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_divides.hpp" 1 3 4
># 34 "/usr/include/boost/type_traits/has_divides.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_divides_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator / (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() / make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() / make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() / make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_divides_impl::dont_care > struct has_divides : public ::boost::integral_constant<bool,(::boost::detail::has_divides_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 35 "/usr/include/boost/type_traits/has_divides.hpp" 2 3 4
># 21 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_divides_assign.hpp" 1 3 4
># 41 "/usr/include/boost/type_traits/has_divides_assign.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_divides_assign_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator /= (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() /= make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() /= make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() /= make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_const< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_divides_assign_impl::dont_care > struct has_divides_assign : public ::boost::integral_constant<bool,(::boost::detail::has_divides_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 42 "/usr/include/boost/type_traits/has_divides_assign.hpp" 2 3 4
># 22 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_equal_to.hpp" 1 3 4
># 43 "/usr/include/boost/type_traits/has_equal_to.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_equal_to_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator == (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() == make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() == make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() == make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::type_traits::ice_or< ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value, ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value, ::boost::is_same< Lhs_noptr, Rhs_noptr >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_void< Rhs_noptr >::value >::value >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_equal_to_impl::dont_care > struct has_equal_to : public ::boost::integral_constant<bool,(::boost::detail::has_equal_to_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 44 "/usr/include/boost/type_traits/has_equal_to.hpp" 2 3 4
># 23 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_greater.hpp" 1 3 4
># 43 "/usr/include/boost/type_traits/has_greater.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_greater_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator > (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() > make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() > make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() > make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::type_traits::ice_or< ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value, ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value, ::boost::is_same< Lhs_noptr, Rhs_noptr >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_void< Rhs_noptr >::value >::value >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_greater_impl::dont_care > struct has_greater : public ::boost::integral_constant<bool,(::boost::detail::has_greater_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 44 "/usr/include/boost/type_traits/has_greater.hpp" 2 3 4
># 24 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_greater_equal.hpp" 1 3 4
># 43 "/usr/include/boost/type_traits/has_greater_equal.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_greater_equal_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator >= (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() >= make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() >= make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() >= make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::type_traits::ice_or< ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value, ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value, ::boost::is_same< Lhs_noptr, Rhs_noptr >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_void< Rhs_noptr >::value >::value >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_greater_equal_impl::dont_care > struct has_greater_equal : public ::boost::integral_constant<bool,(::boost::detail::has_greater_equal_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 44 "/usr/include/boost/type_traits/has_greater_equal.hpp" 2 3 4
># 25 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_left_shift.hpp" 1 3 4
># 43 "/usr/include/boost/type_traits/has_left_shift.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_left_shift_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator << (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() << make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() << make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() << make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_or< ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_left_shift_impl::dont_care > struct has_left_shift : public ::boost::integral_constant<bool,(::boost::detail::has_left_shift_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 44 "/usr/include/boost/type_traits/has_left_shift.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_left_shift_assign.hpp" 1 3 4
># 49 "/usr/include/boost/type_traits/has_left_shift_assign.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_left_shift_assign_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator <<= (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() <<= make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() <<= make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() <<= make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_or< ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_left_shift_assign_impl::dont_care > struct has_left_shift_assign : public ::boost::integral_constant<bool,(::boost::detail::has_left_shift_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 50 "/usr/include/boost/type_traits/has_left_shift_assign.hpp" 2 3 4
># 27 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_less.hpp" 1 3 4
># 43 "/usr/include/boost/type_traits/has_less.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_less_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator < (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() < make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() < make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() < make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::type_traits::ice_or< ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value, ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value, ::boost::is_same< Lhs_noptr, Rhs_noptr >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_void< Rhs_noptr >::value >::value >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_less_impl::dont_care > struct has_less : public ::boost::integral_constant<bool,(::boost::detail::has_less_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 44 "/usr/include/boost/type_traits/has_less.hpp" 2 3 4
># 28 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_less_equal.hpp" 1 3 4
># 43 "/usr/include/boost/type_traits/has_less_equal.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_less_equal_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator <= (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() <= make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() <= make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() <= make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::type_traits::ice_or< ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value, ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value, ::boost::is_same< Lhs_noptr, Rhs_noptr >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_void< Rhs_noptr >::value >::value >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_less_equal_impl::dont_care > struct has_less_equal : public ::boost::integral_constant<bool,(::boost::detail::has_less_equal_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 44 "/usr/include/boost/type_traits/has_less_equal.hpp" 2 3 4
># 29 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_logical_and.hpp" 1 3 4
># 34 "/usr/include/boost/type_traits/has_logical_and.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_logical_and_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator && (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() && make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() && make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() && make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_convertible< Rhs_nocv, bool >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_convertible< Lhs_nocv, bool >::value >::value >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_logical_and_impl::dont_care > struct has_logical_and : public ::boost::integral_constant<bool,(::boost::detail::has_logical_and_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 35 "/usr/include/boost/type_traits/has_logical_and.hpp" 2 3 4
># 30 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_logical_not.hpp" 1 3 4
># 17 "/usr/include/boost/type_traits/has_logical_not.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 1 3 4
># 23 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 24 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3 4
># 34 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
> 
># 35 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_logical_not_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator ! (const any&);
># 76 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((! make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(! make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 144 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((! make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 163 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>template < typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Ret >
>struct trait_impl1 < void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Rhs_noref, Ret, false >::value);
>};
>
>}
>}
>
>
>template< typename Rhs, typename Ret=::boost::detail::has_logical_not_impl::dont_care > struct has_logical_not : public ::boost::integral_constant<bool,(::boost::detail::has_logical_not_impl::trait_impl < Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 210 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
># 18 "/usr/include/boost/type_traits/has_logical_not.hpp" 2 3 4
># 31 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_logical_or.hpp" 1 3 4
># 34 "/usr/include/boost/type_traits/has_logical_or.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_logical_or_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator || (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() || make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() || make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() || make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_convertible< Rhs_nocv, bool >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_convertible< Lhs_nocv, bool >::value >::value >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_logical_or_impl::dont_care > struct has_logical_or : public ::boost::integral_constant<bool,(::boost::detail::has_logical_or_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 35 "/usr/include/boost/type_traits/has_logical_or.hpp" 2 3 4
># 32 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_minus.hpp" 1 3 4
># 54 "/usr/include/boost/type_traits/has_minus.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_minus_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator - (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() - make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() - make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() - make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_void< Rhs_noptr >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::is_same< Lhs_nocv, Rhs_nocv >::value >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_minus_impl::dont_care > struct has_minus : public ::boost::integral_constant<bool,(::boost::detail::has_minus_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 55 "/usr/include/boost/type_traits/has_minus.hpp" 2 3 4
># 33 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_minus_assign.hpp" 1 3 4
># 59 "/usr/include/boost/type_traits/has_minus_assign.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_minus_assign_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator -= (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() -= make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() -= make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() -= make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_void< Rhs_noptr >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_minus_assign_impl::dont_care > struct has_minus_assign : public ::boost::integral_constant<bool,(::boost::detail::has_minus_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 60 "/usr/include/boost/type_traits/has_minus_assign.hpp" 2 3 4
># 34 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_modulus.hpp" 1 3 4
># 43 "/usr/include/boost/type_traits/has_modulus.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_modulus_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator % (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() % make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() % make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() % make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_or< ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_modulus_impl::dont_care > struct has_modulus : public ::boost::integral_constant<bool,(::boost::detail::has_modulus_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 44 "/usr/include/boost/type_traits/has_modulus.hpp" 2 3 4
># 35 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_modulus_assign.hpp" 1 3 4
># 49 "/usr/include/boost/type_traits/has_modulus_assign.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_modulus_assign_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator %= (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() %= make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() %= make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() %= make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_or< ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_modulus_assign_impl::dont_care > struct has_modulus_assign : public ::boost::integral_constant<bool,(::boost::detail::has_modulus_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 50 "/usr/include/boost/type_traits/has_modulus_assign.hpp" 2 3 4
># 36 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_multiplies.hpp" 1 3 4
># 34 "/usr/include/boost/type_traits/has_multiplies.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_multiplies_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator * (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() * make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() * make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() * make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_multiplies_impl::dont_care > struct has_multiplies : public ::boost::integral_constant<bool,(::boost::detail::has_multiplies_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 35 "/usr/include/boost/type_traits/has_multiplies.hpp" 2 3 4
># 37 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_multiplies_assign.hpp" 1 3 4
># 41 "/usr/include/boost/type_traits/has_multiplies_assign.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_multiplies_assign_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator *= (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() *= make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() *= make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() *= make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_const< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_multiplies_assign_impl::dont_care > struct has_multiplies_assign : public ::boost::integral_constant<bool,(::boost::detail::has_multiplies_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 42 "/usr/include/boost/type_traits/has_multiplies_assign.hpp" 2 3 4
># 38 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_negate.hpp" 1 3 4
># 19 "/usr/include/boost/type_traits/has_negate.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 1 3 4
># 23 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 24 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3 4
># 34 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
> 
># 35 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_negate_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator - (const any&);
># 76 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((- make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(- make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 144 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((- make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 163 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>template < typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Ret >
>struct trait_impl1 < void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Rhs_noref, Ret, ::boost::is_pointer< Rhs_noref >::value >::value);
>};
>
>}
>}
>
>
>template< typename Rhs, typename Ret=::boost::detail::has_negate_impl::dont_care > struct has_negate : public ::boost::integral_constant<bool,(::boost::detail::has_negate_impl::trait_impl < Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 210 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
># 20 "/usr/include/boost/type_traits/has_negate.hpp" 2 3 4
># 39 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_not_equal_to.hpp" 1 3 4
># 43 "/usr/include/boost/type_traits/has_not_equal_to.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_not_equal_to_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator != (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() != make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() != make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() != make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::type_traits::ice_or< ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value, ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value, ::boost::is_same< Lhs_noptr, Rhs_noptr >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_void< Rhs_noptr >::value >::value >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_not_equal_to_impl::dont_care > struct has_not_equal_to : public ::boost::integral_constant<bool,(::boost::detail::has_not_equal_to_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 44 "/usr/include/boost/type_traits/has_not_equal_to.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_plus.hpp" 1 3 4
># 48 "/usr/include/boost/type_traits/has_plus.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_plus_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator + (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() + make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() + make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() + make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_void< Rhs_noptr >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_plus_impl::dont_care > struct has_plus : public ::boost::integral_constant<bool,(::boost::detail::has_plus_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 49 "/usr/include/boost/type_traits/has_plus.hpp" 2 3 4
># 41 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_plus_assign.hpp" 1 3 4
># 60 "/usr/include/boost/type_traits/has_plus_assign.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_plus_assign_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator += (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() += make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() += make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() += make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_void< Rhs_noptr >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_same< Lhs_nocv, bool >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_plus_assign_impl::dont_care > struct has_plus_assign : public ::boost::integral_constant<bool,(::boost::detail::has_plus_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 61 "/usr/include/boost/type_traits/has_plus_assign.hpp" 2 3 4
># 42 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_post_decrement.hpp" 1 3 4
># 34 "/usr/include/boost/type_traits/has_post_decrement.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 1 3 4
># 22 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 23 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 2 3 4
>
>
>
> 
># 27 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_post_decrement_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator -- (const any&, int);
># 68 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() --,returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs >
>struct operator_returns_Ret < Lhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs >
>struct operator_returns_Ret < Lhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs >
>struct operator_returns_Ret < Lhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs >
>struct operator_returns_Ret < Lhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct operator_returns_Ret < Lhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Ret >
>struct operator_returns_Ret < Lhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() --))==sizeof(::boost::type_traits::yes_type));
>};
># 136 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() --),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 155 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 3
>template < typename Lhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs >::value, operator_returns_Ret < Lhs, Ret, operator_returns_void < Lhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Ret >
>struct trait_impl1 < void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::is_same< bool, Lhs_nocv >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_void< Lhs_noptr >::value >::value, ::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Ret=::boost::detail::has_post_decrement_impl::dont_care > struct has_post_decrement : public ::boost::integral_constant<bool,(::boost::detail::has_post_decrement_impl::trait_impl< Lhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 202 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 2 3
># 35 "/usr/include/boost/type_traits/has_post_decrement.hpp" 2 3 4
># 43 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_post_increment.hpp" 1 3 4
># 34 "/usr/include/boost/type_traits/has_post_increment.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 1 3 4
># 22 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 23 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 2 3 4
>
>
>
> 
># 27 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_post_increment_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator ++ (const any&, int);
># 68 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() ++,returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs >
>struct operator_returns_Ret < Lhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs >
>struct operator_returns_Ret < Lhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs >
>struct operator_returns_Ret < Lhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs >
>struct operator_returns_Ret < Lhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct operator_returns_Ret < Lhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Ret >
>struct operator_returns_Ret < Lhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() ++))==sizeof(::boost::type_traits::yes_type));
>};
># 136 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() ++),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 155 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 3
>template < typename Lhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs >::value, operator_returns_Ret < Lhs, Ret, operator_returns_void < Lhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Ret >
>struct trait_impl1 < void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::is_same< bool, Lhs_nocv >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_void< Lhs_noptr >::value >::value, ::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Ret=::boost::detail::has_post_increment_impl::dont_care > struct has_post_increment : public ::boost::integral_constant<bool,(::boost::detail::has_post_increment_impl::trait_impl< Lhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 202 "/usr/include/boost/type_traits/detail/has_postfix_operator.hpp" 2 3
># 35 "/usr/include/boost/type_traits/has_post_increment.hpp" 2 3 4
># 44 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_pre_decrement.hpp" 1 3 4
># 34 "/usr/include/boost/type_traits/has_pre_decrement.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 1 3 4
># 23 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 24 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3 4
># 34 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
> 
># 35 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_pre_decrement_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator -- (const any&);
># 76 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((-- make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(-- make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 144 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((-- make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 163 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>template < typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Ret >
>struct trait_impl1 < void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::is_same< bool, Rhs_nocv >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_void< Rhs_noptr >::value >::value, ::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::is_const< Rhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Rhs, typename Ret=::boost::detail::has_pre_decrement_impl::dont_care > struct has_pre_decrement : public ::boost::integral_constant<bool,(::boost::detail::has_pre_decrement_impl::trait_impl < Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 210 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
># 35 "/usr/include/boost/type_traits/has_pre_decrement.hpp" 2 3 4
># 45 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_pre_increment.hpp" 1 3 4
># 34 "/usr/include/boost/type_traits/has_pre_increment.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 1 3 4
># 23 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 24 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3 4
># 34 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
> 
># 35 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_pre_increment_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator ++ (const any&);
># 76 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((++ make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(++ make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 144 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((++ make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 163 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>template < typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Ret >
>struct trait_impl1 < void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::is_same< bool, Rhs_nocv >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_void< Rhs_noptr >::value >::value, ::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::is_const< Rhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Rhs, typename Ret=::boost::detail::has_pre_increment_impl::dont_care > struct has_pre_increment : public ::boost::integral_constant<bool,(::boost::detail::has_pre_increment_impl::trait_impl < Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 210 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
># 35 "/usr/include/boost/type_traits/has_pre_increment.hpp" 2 3 4
># 46 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_right_shift.hpp" 1 3 4
># 43 "/usr/include/boost/type_traits/has_right_shift.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_right_shift_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator >> (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() >> make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() >> make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() >> make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_or< ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_right_shift_impl::dont_care > struct has_right_shift : public ::boost::integral_constant<bool,(::boost::detail::has_right_shift_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 44 "/usr/include/boost/type_traits/has_right_shift.hpp" 2 3 4
># 47 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_right_shift_assign.hpp" 1 3 4
># 49 "/usr/include/boost/type_traits/has_right_shift_assign.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
> 
># 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_right_shift_assign_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator >>= (const any&, const any&);
># 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() >>= make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Lhs, typename Rhs >
>struct operator_returns_Ret < Lhs, Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() >>= make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Lhs, typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((make<Lhs>() >>= make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
>template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl1 < Lhs, Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < void, Rhs, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Lhs, typename Ret >
>struct trait_impl1 < Lhs, void, Ret, false > {
> static const bool value = false;
>};
>
>template < typename Ret >
>struct trait_impl1 < void, void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Lhs, typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_or< ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
>};
>
>}
>}
>
>
>template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_right_shift_assign_impl::dont_care > struct has_right_shift_assign : public ::boost::integral_constant<bool,(::boost::detail::has_right_shift_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
># 50 "/usr/include/boost/type_traits/has_right_shift_assign.hpp" 2 3 4
># 48 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_unary_minus.hpp" 1 3 4
># 19 "/usr/include/boost/type_traits/has_unary_minus.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 1 3 4
># 23 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 24 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3 4
># 34 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
> 
># 35 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_unary_minus_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator - (const any&);
># 76 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((- make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(- make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 144 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((- make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 163 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>template < typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Ret >
>struct trait_impl1 < void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Rhs_noref, Ret, ::boost::is_pointer< Rhs_noref >::value >::value);
>};
>
>}
>}
>
>
>template< typename Rhs, typename Ret=::boost::detail::has_unary_minus_impl::dont_care > struct has_unary_minus : public ::boost::integral_constant<bool,(::boost::detail::has_unary_minus_impl::trait_impl < Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 210 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
># 20 "/usr/include/boost/type_traits/has_unary_minus.hpp" 2 3 4
># 49 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_unary_plus.hpp" 1 3 4
># 17 "/usr/include/boost/type_traits/has_unary_plus.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 1 3 4
># 23 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 24 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3 4
># 34 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3 4
> 
># 35 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>
>
>
>
>
>namespace boost {
>namespace detail {
>
>
>namespace has_unary_plus_impl {
>
>
>
>template <typename T> T &make();
>
>
>
>
>
>
>
>struct no_operator { };
>
>
>
>
>struct any { template <class T> any(T const&); };
>
>
>no_operator operator + (const any&);
># 76 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct returns_void_t { };
>template <typename T> int operator,(const T&, returns_void_t);
>template <typename T> int operator,(const volatile T&, returns_void_t);
>
>
>
>
>template < typename Rhs >
>struct operator_returns_void {
>
>
> static ::boost::type_traits::yes_type returns_void(returns_void_t);
> static ::boost::type_traits::no_type returns_void(int);
> static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((+ make<Rhs>(),returns_void_t()))));
>};
>
>
>
>
>
>struct dont_care { };
>
>template < typename Rhs, typename Ret, bool Returns_void >
>struct operator_returns_Ret;
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, dont_care, false > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, true > {
> static const bool value = true;
>};
>
>template < typename Rhs >
>struct operator_returns_Ret < Rhs, void, false > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>
>
>
>template < typename Rhs, typename Ret >
>struct operator_returns_Ret < Rhs, Ret, false > {
> static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
> static ::boost::type_traits::no_type is_convertible_to_Ret(...);
>
> static const bool value = (sizeof(is_convertible_to_Ret(+ make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
>};
># 144 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>struct has_operator { };
>no_operator operator,(no_operator, has_operator);
>
>template < typename Rhs >
>struct operator_exists {
> static ::boost::type_traits::yes_type check(has_operator);
> static ::boost::type_traits::no_type check(no_operator);
>
> static const bool value = (sizeof(check(((+ make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
>};
># 163 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
>template < typename Rhs, typename Ret, bool Forbidden_if >
>struct trait_impl1;
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, true > {
> static const bool value = false;
>};
>
>template < typename Rhs, typename Ret >
>struct trait_impl1 < Rhs, Ret, false > {
> static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )
>
>
>
>
>
>
> ;
>};
>
>
>template < typename Ret >
>struct trait_impl1 < void, Ret, false > {
> static const bool value = false;
>};
>
>
>template < typename Rhs, typename Ret >
>struct trait_impl {
> typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
> typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
> typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
> static const bool value = (trait_impl1 < Rhs_noref, Ret, false >::value);
>};
>
>}
>}
>
>
>template< typename Rhs, typename Ret=::boost::detail::has_unary_plus_impl::dont_care > struct has_unary_plus : public ::boost::integral_constant<bool,(::boost::detail::has_unary_plus_impl::trait_impl < Rhs, Ret >::value)> { public: };
>
>}
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 210 "/usr/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
># 18 "/usr/include/boost/type_traits/has_unary_plus.hpp" 2 3 4
># 50 "/usr/include/boost/type_traits/has_operator.hpp" 2 3 4
># 36 "/usr/include/boost/type_traits.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/type_traits/has_trivial_move_assign.hpp" 1 3 4
># 22 "/usr/include/boost/type_traits/has_trivial_move_assign.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 23 "/usr/include/boost/type_traits/has_trivial_move_assign.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
>
>template <typename T>
>struct has_trivial_move_assign_impl
>{
>
>
>
> static const bool value = (::boost::type_traits::ice_and< ::boost::is_pod<T>::value, ::boost::type_traits::ice_not< ::boost::is_const<T>::value >::value, ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value >::value)
>
>
>
>
> ;
>
>};
>
>}
>
>template< typename T > struct has_trivial_move_assign : public ::boost::integral_constant<bool,::boost::detail::has_trivial_move_assign_impl<T>::value> { public: };
>template<> struct has_trivial_move_assign< void > : public ::boost::integral_constant<bool,false> { public: };
>
>template<> struct has_trivial_move_assign< void const > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_trivial_move_assign< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_trivial_move_assign< void volatile > : public ::boost::integral_constant<bool,false> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 56 "/usr/include/boost/type_traits/has_trivial_move_assign.hpp" 2 3 4
># 41 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_trivial_move_constructor.hpp" 1 3 4
># 22 "/usr/include/boost/type_traits/has_trivial_move_constructor.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 23 "/usr/include/boost/type_traits/has_trivial_move_constructor.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
>
>template <typename T>
>struct has_trivial_move_ctor_impl
>{
>
>
>
> static const bool value = (::boost::type_traits::ice_and< ::boost::is_pod<T>::value, ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value >::value)
>
>
>
> ;
>
>};
>
>}
>
>template< typename T > struct has_trivial_move_constructor : public ::boost::integral_constant<bool,::boost::detail::has_trivial_move_ctor_impl<T>::value> { public: };
>
>template<> struct has_trivial_move_constructor< void > : public ::boost::integral_constant<bool,false> { public: };
>
>template<> struct has_trivial_move_constructor< void const > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_trivial_move_constructor< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct has_trivial_move_constructor< void volatile > : public ::boost::integral_constant<bool,false> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 56 "/usr/include/boost/type_traits/has_trivial_move_constructor.hpp" 2 3 4
># 42 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/has_virtual_destructor.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/has_virtual_destructor.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 16 "/usr/include/boost/type_traits/has_virtual_destructor.hpp" 2 3 4
>
>namespace boost {
>
>
>template< typename T > struct has_virtual_destructor : public ::boost::integral_constant<bool,__has_virtual_destructor(T)> { public: };
>
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 28 "/usr/include/boost/type_traits/has_virtual_destructor.hpp" 2 3 4
># 43 "/usr/include/boost/type_traits.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/is_complex.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/is_complex.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 15 "/usr/include/boost/type_traits/is_complex.hpp" 2 3 4
>
>
>namespace boost {
>namespace detail{
>
>struct is_convertible_from_tester
>{
> template <class T>
> is_convertible_from_tester(const std::complex<T>&);
>};
>
>}
>
>template< typename T > struct is_complex : public ::boost::integral_constant<bool,(::boost::is_convertible<T, boost::detail::is_convertible_from_tester>::value)> { public: };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 33 "/usr/include/boost/type_traits/is_complex.hpp" 2 3 4
># 50 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_compound.hpp" 1 3 4
># 17 "/usr/include/boost/type_traits/is_compound.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 18 "/usr/include/boost/type_traits/is_compound.hpp" 2 3 4
>
>namespace boost {
>
>
>namespace detail {
>
>template <typename T>
>struct is_compound_impl
>{
> static const bool value = (::boost::type_traits::ice_not< ::boost::is_fundamental<T>::value >::value)
>
>
> ;
>};
>
>}
>
>
>
>
>
>template< typename T > struct is_compound : public ::boost::integral_constant<bool,::boost::detail::is_compound_impl<T>::value> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 45 "/usr/include/boost/type_traits/is_compound.hpp" 2 3 4
># 51 "/usr/include/boost/type_traits.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/is_floating_point.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/is_floating_point.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 14 "/usr/include/boost/type_traits/is_floating_point.hpp" 2 3 4
>
>namespace boost {
>
>
>template< typename T > struct is_floating_point : public ::boost::integral_constant<bool,false> { public: };
>template<> struct is_floating_point< float > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< float const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< float volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< float const volatile > : public ::boost::integral_constant<bool,true> { public: };
>template<> struct is_floating_point< double > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< double const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< double volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< double const volatile > : public ::boost::integral_constant<bool,true> { public: };
>template<> struct is_floating_point< long double > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< long double const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< long double volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< long double const volatile > : public ::boost::integral_constant<bool,true> { public: };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 26 "/usr/include/boost/type_traits/is_floating_point.hpp" 2 3 4
># 57 "/usr/include/boost/type_traits.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/is_member_object_pointer.hpp" 1 3 4
># 20 "/usr/include/boost/type_traits/is_member_object_pointer.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 21 "/usr/include/boost/type_traits/is_member_object_pointer.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail{
>
>template <typename T>
>struct is_member_object_pointer_impl
>{
> static const bool value = (::boost::type_traits::ice_and< ::boost::is_member_pointer<T>::value, ::boost::type_traits::ice_not< ::boost::is_member_function_pointer<T>::value >::value >::value )
>
>
>
>
>
> ;
>};
>
>}
>
>template< typename T > struct is_member_object_pointer : public ::boost::integral_constant<bool,::boost::detail::is_member_object_pointer_impl<T>::value> { public: };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 45 "/usr/include/boost/type_traits/is_member_object_pointer.hpp" 2 3 4
># 63 "/usr/include/boost/type_traits.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/is_nothrow_move_assignable.hpp" 1 3 4
># 26 "/usr/include/boost/type_traits/is_nothrow_move_assignable.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 27 "/usr/include/boost/type_traits/is_nothrow_move_assignable.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail{
>
>
>
>template <class T, class Enable = void>
>struct false_or_cpp11_noexcept_move_assignable: public ::boost::false_type {};
>
>template <class T>
>struct false_or_cpp11_noexcept_move_assignable <
> T,
> typename ::boost::enable_if_c<sizeof(T) && noexcept((::boost::declval<T&>() = ::boost::declval<T>()))>::type
> > : public ::boost::integral_constant<bool, noexcept((::boost::declval<T&>() = ::boost::declval<T>()))>
>{};
>
>template <class T>
>struct is_nothrow_move_assignable_imp{
> static const bool value = ( ::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value, ::boost::type_traits::ice_not< ::boost::is_reference<T>::value >::value, ::boost::detail::false_or_cpp11_noexcept_move_assignable<T>::value >::value)
>
>
>
>
> ;
>};
># 70 "/usr/include/boost/type_traits/is_nothrow_move_assignable.hpp" 3 4
>}
>
>template< typename T > struct is_nothrow_move_assignable : public ::boost::integral_constant<bool,::boost::detail::is_nothrow_move_assignable_imp<T>::value> { public: };
>template<> struct is_nothrow_move_assignable< void > : public ::boost::integral_constant<bool,false> { public: };
>
>template<> struct is_nothrow_move_assignable< void const > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct is_nothrow_move_assignable< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct is_nothrow_move_assignable< void volatile > : public ::boost::integral_constant<bool,false> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 83 "/usr/include/boost/type_traits/is_nothrow_move_assignable.hpp" 2 3 4
># 65 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_nothrow_move_constructible.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/is_nothrow_move_constructible.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 26 "/usr/include/boost/type_traits/is_nothrow_move_constructible.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail{
>
>
>
>template <class T, class Enable = void>
>struct false_or_cpp11_noexcept_move_constructible: public ::boost::false_type {};
>
>template <class T>
>struct false_or_cpp11_noexcept_move_constructible <
> T,
> typename ::boost::enable_if_c<sizeof(T) && noexcept((T(::boost::declval<T>())))>::type
> > : public ::boost::integral_constant<bool, noexcept((T(::boost::declval<T>())))>
>{};
>
>template <class T>
>struct is_nothrow_move_constructible_imp{
> static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value, ::boost::type_traits::ice_not< ::boost::is_reference<T>::value >::value, ::boost::detail::false_or_cpp11_noexcept_move_constructible<T>::value >::value)
>
>
>
>
> ;
>};
># 69 "/usr/include/boost/type_traits/is_nothrow_move_constructible.hpp" 3 4
>}
>
>template< typename T > struct is_nothrow_move_constructible : public ::boost::integral_constant<bool,::boost::detail::is_nothrow_move_constructible_imp<T>::value> { public: };
>
>template<> struct is_nothrow_move_constructible< void > : public ::boost::integral_constant<bool,false> { public: };
>
>template<> struct is_nothrow_move_constructible< void const > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct is_nothrow_move_constructible< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
>template<> struct is_nothrow_move_constructible< void volatile > : public ::boost::integral_constant<bool,false> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 83 "/usr/include/boost/type_traits/is_nothrow_move_constructible.hpp" 2 3 4
># 66 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_object.hpp" 1 3 4
># 20 "/usr/include/boost/type_traits/is_object.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 21 "/usr/include/boost/type_traits/is_object.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
>
>template <typename T>
>struct is_object_impl
>{
>
> static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value, ::boost::type_traits::ice_not< ::boost::is_void<T>::value>::value, ::boost::type_traits::ice_not< ::boost::is_function<T>::value>::value >::value)
>
>
>
>
> ;
>
>
>
>
>
>
>
>};
>
>}
>
>template< typename T > struct is_object : public ::boost::integral_constant<bool,::boost::detail::is_object_impl<T>::value> { public: };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 52 "/usr/include/boost/type_traits/is_object.hpp" 2 3 4
># 67 "/usr/include/boost/type_traits.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/is_polymorphic.hpp" 1 3 4
># 17 "/usr/include/boost/type_traits/is_polymorphic.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 18 "/usr/include/boost/type_traits/is_polymorphic.hpp" 2 3 4
>
>
>namespace boost{
># 106 "/usr/include/boost/type_traits/is_polymorphic.hpp" 3 4
>template< typename T > struct is_polymorphic : public ::boost::integral_constant<bool,__is_polymorphic(T)> { public: };
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 113 "/usr/include/boost/type_traits/is_polymorphic.hpp" 2 3 4
># 69 "/usr/include/boost/type_traits.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/type_traits/is_signed.hpp" 1 3 4
># 19 "/usr/include/boost/type_traits/is_signed.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 20 "/usr/include/boost/type_traits/is_signed.hpp" 2 3 4
>
>namespace boost {
>
>
>
>namespace detail{
>
>
>
>template <class T>
>struct is_signed_values
>{
>
>
>
>
>
> typedef typename remove_cv<T>::type no_cv_t;
> static const no_cv_t minus_one = (static_cast<no_cv_t>(-1));
> static const no_cv_t zero = (static_cast<no_cv_t>(0));
>};
>
>template <class T>
>struct is_signed_helper
>{
> typedef typename remove_cv<T>::type no_cv_t;
> static const bool value = (!(::boost::detail::is_signed_values<T>::minus_one > boost::detail::is_signed_values<T>::zero));
>};
>
>template <bool integral_type>
>struct is_signed_select_helper
>{
> template <class T>
> struct rebind
> {
> typedef is_signed_helper<T> type;
> };
>};
>
>template <>
>struct is_signed_select_helper<false>
>{
> template <class T>
> struct rebind
> {
> typedef false_type type;
> };
>};
>
>template <class T>
>struct is_signed_imp
>{
> typedef is_signed_select_helper<
> ::boost::type_traits::ice_or<
> ::boost::is_integral<T>::value,
> ::boost::is_enum<T>::value>::value
> > selector;
> typedef typename selector::template rebind<T> binder;
> typedef typename binder::type type;
>
>
>
> static const bool value = type::value;
>
>};
># 126 "/usr/include/boost/type_traits/is_signed.hpp" 3 4
>}
>
>
>
>
>
>
>template< typename T > struct is_signed : public ::boost::integral_constant<bool,::boost::detail::is_signed_imp<T>::value> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 139 "/usr/include/boost/type_traits/is_signed.hpp" 2 3 4
># 73 "/usr/include/boost/type_traits.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/type_traits/is_union.hpp" 1 3 4
># 19 "/usr/include/boost/type_traits/is_union.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 20 "/usr/include/boost/type_traits/is_union.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
># 40 "/usr/include/boost/type_traits/is_union.hpp" 3 4
>template <typename T> struct is_union_impl
>{
>
> static const bool value = __is_union(T);
>
>
>
>};
>
>}
>
>template< typename T > struct is_union : public ::boost::integral_constant<bool,::boost::detail::is_union_impl<T>::value> { public: };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 56 "/usr/include/boost/type_traits/is_union.hpp" 2 3 4
># 77 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_unsigned.hpp" 1 3 4
># 19 "/usr/include/boost/type_traits/is_unsigned.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 20 "/usr/include/boost/type_traits/is_unsigned.hpp" 2 3 4
>
>namespace boost {
>
>
>
>namespace detail{
>
>
>
>template <class T>
>struct is_unsigned_values
>{
>
>
>
>
>
> typedef typename remove_cv<T>::type no_cv_t;
> static const no_cv_t minus_one = (static_cast<no_cv_t>(-1));
> static const no_cv_t zero = (static_cast<no_cv_t>(0));
>};
>
>template <class T>
>struct is_ununsigned_helper
>{
> static const bool value = (::boost::detail::is_unsigned_values<T>::minus_one > ::boost::detail::is_unsigned_values<T>::zero);
>};
>
>template <bool integral_type>
>struct is_ununsigned_select_helper
>{
> template <class T>
> struct rebind
> {
> typedef is_ununsigned_helper<T> type;
> };
>};
>
>template <>
>struct is_ununsigned_select_helper<false>
>{
> template <class T>
> struct rebind
> {
> typedef false_type type;
> };
>};
>
>template <class T>
>struct is_unsigned_imp
>{
> typedef is_ununsigned_select_helper<
> ::boost::type_traits::ice_or<
> ::boost::is_integral<T>::value,
> ::boost::is_enum<T>::value>::value
> > selector;
> typedef typename selector::template rebind<T> binder;
> typedef typename binder::type type;
> static const bool value = type::value;
>};
># 121 "/usr/include/boost/type_traits/is_unsigned.hpp" 3 4
>}
>
>
>
>
>
>
>template< typename T > struct is_unsigned : public ::boost::integral_constant<bool,::boost::detail::is_unsigned_imp<T>::value> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 134 "/usr/include/boost/type_traits/is_unsigned.hpp" 2 3 4
># 78 "/usr/include/boost/type_traits.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/is_virtual_base_of.hpp" 1 3 4
># 17 "/usr/include/boost/type_traits/is_virtual_base_of.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 18 "/usr/include/boost/type_traits/is_virtual_base_of.hpp" 2 3 4
>
>namespace boost {
>namespace detail {
>
>
>
>
>
>
> 
># 28 "/usr/include/boost/type_traits/is_virtual_base_of.hpp" 3
>
>
>template<typename Base, typename Derived, typename tag>
>struct is_virtual_base_of_impl
>{
> static const bool value = false;
>};
>
>template<typename Base, typename Derived>
>struct is_virtual_base_of_impl<Base, Derived, mpl::true_>
>{
># 55 "/usr/include/boost/type_traits/is_virtual_base_of.hpp" 3
> struct boost_type_traits_internal_struct_X : public Derived, virtual Base
> {
> boost_type_traits_internal_struct_X();
> boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&);
> boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&);
> ~boost_type_traits_internal_struct_X()throw();
> };
> struct boost_type_traits_internal_struct_Y : public Derived
> {
> boost_type_traits_internal_struct_Y();
> boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&);
> boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&);
> ~boost_type_traits_internal_struct_Y()throw();
> };
>
> static const bool value = (sizeof(boost_type_traits_internal_struct_X)==sizeof(boost_type_traits_internal_struct_Y));
>};
>
>template<typename Base, typename Derived>
>struct is_virtual_base_of_impl2
>{
> typedef typename mpl::and_<is_base_of<Base, Derived>, mpl::not_<is_same<Base, Derived> > >::type tag_type;
> typedef is_virtual_base_of_impl<Base, Derived, tag_type> imp;
> static const bool value = imp::value;
>};
>
>
>
>
>
>}
>
>template< typename Base, typename Derived > struct is_virtual_base_of : public ::boost::integral_constant<bool,(::boost::detail::is_virtual_base_of_impl2<Base,Derived>::value)> { public: };
>
>
>
>
>
>
>
>template< typename Base, typename Derived > struct is_virtual_base_of< Base&,Derived > : public ::boost::integral_constant<bool,false> { public: };
>template< typename Base, typename Derived > struct is_virtual_base_of< Base,Derived& > : public ::boost::integral_constant<bool,false> { public: };
>template< typename Base, typename Derived > struct is_virtual_base_of< Base&,Derived& > : public ::boost::integral_constant<bool,false> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 103 "/usr/include/boost/type_traits/is_virtual_base_of.hpp" 2 3
># 80 "/usr/include/boost/type_traits.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/make_unsigned.hpp" 1 3 4
># 29 "/usr/include/boost/type_traits/make_unsigned.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 30 "/usr/include/boost/type_traits/make_unsigned.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
>
>template <class T>
>struct make_unsigned_imp
>{
> static_assert((::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value), "(::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value)")
> ;
>
> static_assert((::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value), "(::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value)")
>
> ;
>
>
> typedef typename remove_cv<T>::type t_no_cv;
> typedef typename mpl::if_c<
> (::boost::type_traits::ice_and<
> ::boost::is_unsigned<T>::value,
> ::boost::is_integral<T>::value,
> ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
> ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
> ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
> T,
> typename mpl::if_c<
> (::boost::type_traits::ice_and<
> ::boost::is_integral<T>::value,
> ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
> ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
> ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
> ::value),
> typename mpl::if_<
> is_same<t_no_cv, signed char>,
> unsigned char,
> typename mpl::if_<
> is_same<t_no_cv, short>,
> unsigned short,
> typename mpl::if_<
> is_same<t_no_cv, int>,
> unsigned int,
> typename mpl::if_<
> is_same<t_no_cv, long>,
> unsigned long,
>
>
> typename mpl::if_c<
> sizeof(t_no_cv) == sizeof(boost::ulong_long_type),
> boost::ulong_long_type,
> boost::uint128_type
> >::type
># 89 "/usr/include/boost/type_traits/make_unsigned.hpp" 3 4
> >::type
> >::type
> >::type
> >::type,
>
> typename mpl::if_c<
> sizeof(t_no_cv) == sizeof(unsigned char),
> unsigned char,
> typename mpl::if_c<
> sizeof(t_no_cv) == sizeof(unsigned short),
> unsigned short,
> typename mpl::if_c<
> sizeof(t_no_cv) == sizeof(unsigned int),
> unsigned int,
> typename mpl::if_c<
> sizeof(t_no_cv) == sizeof(unsigned long),
> unsigned long,
>
>
> typename mpl::if_c<
> sizeof(t_no_cv) == sizeof(boost::ulong_long_type),
> boost::ulong_long_type,
> boost::uint128_type
> >::type
># 121 "/usr/include/boost/type_traits/make_unsigned.hpp" 3 4
> >::type
> >::type
> >::type
> >::type
> >::type
> >::type base_integer_type;
>
>
> typedef typename mpl::if_<
> is_const<T>,
> typename add_const<base_integer_type>::type,
> base_integer_type
> >::type const_base_integer_type;
>
>
> typedef typename mpl::if_<
> is_volatile<T>,
> typename add_volatile<const_base_integer_type>::type,
> const_base_integer_type
> >::type type;
>};
>
>
>}
>
>template< typename T > struct make_unsigned { public: typedef typename boost::detail::make_unsigned_imp<T>::type type; };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 151 "/usr/include/boost/type_traits/make_unsigned.hpp" 2 3 4
># 82 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/make_signed.hpp" 1 3 4
># 29 "/usr/include/boost/type_traits/make_signed.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 30 "/usr/include/boost/type_traits/make_signed.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
>
>template <class T>
>struct make_signed_imp
>{
> static_assert((::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value), "(::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value)")
> ;
>
> static_assert((::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value), "(::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value)")
>
> ;
>
>
> typedef typename remove_cv<T>::type t_no_cv;
> typedef typename mpl::if_c<
> (::boost::type_traits::ice_and<
> ::boost::is_signed<T>::value,
> ::boost::is_integral<T>::value,
> ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
> ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
> ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
> T,
> typename mpl::if_c<
> (::boost::type_traits::ice_and<
> ::boost::is_integral<T>::value,
> ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
> ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
> ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
> ::value),
> typename mpl::if_<
> is_same<t_no_cv, unsigned char>,
> signed char,
> typename mpl::if_<
> is_same<t_no_cv, unsigned short>,
> signed short,
> typename mpl::if_<
> is_same<t_no_cv, unsigned int>,
> int,
> typename mpl::if_<
> is_same<t_no_cv, unsigned long>,
> long,
>
>
> typename mpl::if_c<
> sizeof(t_no_cv) == sizeof(boost::long_long_type),
> boost::long_long_type,
> boost::int128_type
> >::type
># 89 "/usr/include/boost/type_traits/make_signed.hpp" 3 4
> >::type
> >::type
> >::type
> >::type,
>
> typename mpl::if_c<
> sizeof(t_no_cv) == sizeof(unsigned char),
> signed char,
> typename mpl::if_c<
> sizeof(t_no_cv) == sizeof(unsigned short),
> signed short,
> typename mpl::if_c<
> sizeof(t_no_cv) == sizeof(unsigned int),
> int,
> typename mpl::if_c<
> sizeof(t_no_cv) == sizeof(unsigned long),
> long,
>
>
> typename mpl::if_c<
> sizeof(t_no_cv) == sizeof(boost::long_long_type),
> boost::long_long_type,
> boost::int128_type
> >::type
># 121 "/usr/include/boost/type_traits/make_signed.hpp" 3 4
> >::type
> >::type
> >::type
> >::type
> >::type
> >::type base_integer_type;
>
>
> typedef typename mpl::if_<
> is_const<T>,
> typename add_const<base_integer_type>::type,
> base_integer_type
> >::type const_base_integer_type;
>
>
> typedef typename mpl::if_<
> is_volatile<T>,
> typename add_volatile<const_base_integer_type>::type,
> const_base_integer_type
> >::type type;
>};
>
>
>}
>
>template< typename T > struct make_signed { public: typedef typename boost::detail::make_signed_imp<T>::type type; };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 151 "/usr/include/boost/type_traits/make_signed.hpp" 2 3 4
># 83 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/rank.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/rank.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 2 3 4
># 15 "/usr/include/boost/type_traits/rank.hpp" 2 3 4
>
>namespace boost {
>
>
>
>namespace detail{
>
>template <class T, std::size_t N>
>struct rank_imp
>{
> static const std::size_t value = N;
>};
>
>template <class T, std::size_t R, std::size_t N>
>struct rank_imp<T[R], N>
>{
> static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
>};
>
>template <class T, std::size_t R, std::size_t N>
>struct rank_imp<T const[R], N>
>{
> static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
>};
>
>template <class T, std::size_t R, std::size_t N>
>struct rank_imp<T volatile[R], N>
>{
> static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
>};
>
>template <class T, std::size_t R, std::size_t N>
>struct rank_imp<T const volatile[R], N>
>{
> static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
>};
>
>
>template <class T, std::size_t N>
>struct rank_imp<T[], N>
>{
> static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
>};
>template <class T, std::size_t N>
>struct rank_imp<T const[], N>
>{
> static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
>};
>template <class T, std::size_t N>
>struct rank_imp<T volatile[], N>
>{
> static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
>};
>template <class T, std::size_t N>
>struct rank_imp<T const volatile[], N>
>{
> static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
>};
>
>
>}
>
>
>
>
>
>
>template< typename T > struct rank : public ::boost::integral_constant<std::size_t,(::boost::detail::rank_imp<T,0>::value)> { public: };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/size_t_trait_undef.hpp" 1 3 4
># 88 "/usr/include/boost/type_traits/rank.hpp" 2 3 4
># 84 "/usr/include/boost/type_traits.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/remove_extent.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/remove_extent.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 15 "/usr/include/boost/type_traits/remove_extent.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 22 "/usr/include/boost/type_traits/remove_extent.hpp" 2 3 4
>
>
>
>namespace boost {
>
>template< typename T > struct remove_extent { public: typedef T type; };
>
>
>template< typename T, std::size_t N > struct remove_extent<T[N]> { public: typedef T type; };
>template< typename T, std::size_t N > struct remove_extent<T const[N]> { public: typedef T const type; };
>template< typename T, std::size_t N > struct remove_extent<T volatile[N]> { public: typedef T volatile type; };
>template< typename T, std::size_t N > struct remove_extent<T const volatile[N]> { public: typedef T const volatile type; };
>
>template< typename T > struct remove_extent<T[]> { public: typedef T type; };
>template< typename T > struct remove_extent<T const[]> { public: typedef T const type; };
>template< typename T > struct remove_extent<T volatile[]> { public: typedef T volatile type; };
>template< typename T > struct remove_extent<T const volatile[]> { public: typedef T const volatile type; };
>
>
>
>}
>
>
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 47 "/usr/include/boost/type_traits/remove_extent.hpp" 2 3 4
># 86 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/remove_all_extents.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/remove_all_extents.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 14 "/usr/include/boost/type_traits/remove_all_extents.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 22 "/usr/include/boost/type_traits/remove_all_extents.hpp" 2 3 4
>
>
>
>namespace boost {
>
>template< typename T > struct remove_all_extents { public: typedef T type; };
>
>
>template< typename T, std::size_t N > struct remove_all_extents<T[N]> { public: typedef typename boost::remove_all_extents<T>::type type; };
>template< typename T, std::size_t N > struct remove_all_extents<T const[N]> { public: typedef typename boost::remove_all_extents<T const>::type type; };
>template< typename T, std::size_t N > struct remove_all_extents<T volatile[N]> { public: typedef typename boost::remove_all_extents<T volatile>::type type; };
>template< typename T, std::size_t N > struct remove_all_extents<T const volatile[N]> { public: typedef typename boost::remove_all_extents<T const volatile>::type type; };
>
>template< typename T > struct remove_all_extents<T[]> { public: typedef typename boost::remove_all_extents<T>::type type; };
>template< typename T > struct remove_all_extents<T const[]> { public: typedef typename boost::remove_all_extents<T const>::type type; };
>template< typename T > struct remove_all_extents<T volatile[]> { public: typedef typename boost::remove_all_extents<T volatile>::type type; };
>template< typename T > struct remove_all_extents<T const volatile[]> { public: typedef typename boost::remove_all_extents<T const volatile>::type type; };
>
>
>
>}
>
>
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 47 "/usr/include/boost/type_traits/remove_all_extents.hpp" 2 3 4
># 87 "/usr/include/boost/type_traits.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/type_traits/remove_volatile.hpp" 1 3 4
># 20 "/usr/include/boost/type_traits/remove_volatile.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 21 "/usr/include/boost/type_traits/remove_volatile.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 28 "/usr/include/boost/type_traits/remove_volatile.hpp" 2 3 4
>
>namespace boost {
>
>
>
>namespace detail {
>
>template <typename T, bool is_const>
>struct remove_volatile_helper
>{
> typedef T type;
>};
>
>template <typename T>
>struct remove_volatile_helper<T,true>
>{
> typedef T const type;
>};
>
>template <typename T>
>struct remove_volatile_impl
>{
> typedef typename remove_volatile_helper<
> typename cv_traits_imp<T*>::unqualified_type
> , ::boost::is_const<T>::value
> >::type type;
>};
>
>
>
>
>
>
>template <typename T>
>struct remove_volatile_impl<T&&>
>{
> typedef T&& type;
>};
>
>}
>
>
>
>template< typename T > struct remove_volatile { public: typedef typename boost::detail::remove_volatile_impl<T>::type type; };
>template< typename T > struct remove_volatile<T&> { public: typedef T& type; };
>
>template< typename T, std::size_t N > struct remove_volatile<T volatile[N]> { public: typedef T type[N]; };
>template< typename T, std::size_t N > struct remove_volatile<T const volatile[N]> { public: typedef T const type[N]; };
># 84 "/usr/include/boost/type_traits/remove_volatile.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 87 "/usr/include/boost/type_traits/remove_volatile.hpp" 2 3 4
># 92 "/usr/include/boost/type_traits.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/type_traits/integral_promotion.hpp" 1 3 4
># 20 "/usr/include/boost/type_traits/integral_promotion.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 21 "/usr/include/boost/type_traits/integral_promotion.hpp" 2 3 4
>
>namespace boost {
>
>namespace type_traits { namespace detail {
>
>
>template <class T> struct need_promotion : public boost::is_enum<T> {};
>
>
>template<> struct need_promotion<char > : public true_type {};
>template<> struct need_promotion<signed char > : public true_type {};
>template<> struct need_promotion<unsigned char > : public true_type {};
>template<> struct need_promotion<signed short int > : public true_type {};
>template<> struct need_promotion<unsigned short int> : public true_type {};
># 63 "/usr/include/boost/type_traits/integral_promotion.hpp" 3 4
>template<> struct need_promotion<boost::ulong_long_type> : public integral_constant<bool, (sizeof(boost::ulong_long_type) < sizeof(int))> {};
>template<> struct need_promotion<boost::long_long_type> : public integral_constant<bool, (sizeof(boost::long_long_type) < sizeof(int))> {};
># 75 "/usr/include/boost/type_traits/integral_promotion.hpp" 3 4
>template<> struct need_promotion<wchar_t> : public true_type {};
>
>
>
>
>
>template<> struct need_promotion<bool> : public true_type {};
>
>
>
>
>template<int Index, int IsConst, int IsVolatile> struct promote_from_index;
># 95 "/usr/include/boost/type_traits/integral_promotion.hpp" 3 4
>template<> struct promote_from_index<1,0,0> { typedef int type; }; template<> struct promote_from_index<1,0,1> { typedef int volatile type; }; template<> struct promote_from_index<1,1,0> { typedef int const type; }; template<> struct promote_from_index<1,1,1> { typedef int const volatile type; };
>template<> struct promote_from_index<2,0,0> { typedef unsigned int type; }; template<> struct promote_from_index<2,0,1> { typedef unsigned int volatile type; }; template<> struct promote_from_index<2,1,0> { typedef unsigned int const type; }; template<> struct promote_from_index<2,1,1> { typedef unsigned int const volatile type; };
>template<> struct promote_from_index<3,0,0> { typedef long type; }; template<> struct promote_from_index<3,0,1> { typedef long volatile type; }; template<> struct promote_from_index<3,1,0> { typedef long const type; }; template<> struct promote_from_index<3,1,1> { typedef long const volatile type; };
>template<> struct promote_from_index<4,0,0> { typedef unsigned long type; }; template<> struct promote_from_index<4,0,1> { typedef unsigned long volatile type; }; template<> struct promote_from_index<4,1,0> { typedef unsigned long const type; }; template<> struct promote_from_index<4,1,1> { typedef unsigned long const volatile type; };
># 107 "/usr/include/boost/type_traits/integral_promotion.hpp" 3 4
>template<> struct promote_from_index<5,0,0> { typedef boost::long_long_type type; }; template<> struct promote_from_index<5,0,1> { typedef boost::long_long_type volatile type; }; template<> struct promote_from_index<5,1,0> { typedef boost::long_long_type const type; }; template<> struct promote_from_index<5,1,1> { typedef boost::long_long_type const volatile type; };
>template<> struct promote_from_index<6,0,0> { typedef boost::ulong_long_type type; }; template<> struct promote_from_index<6,0,1> { typedef boost::ulong_long_type volatile type; }; template<> struct promote_from_index<6,1,0> { typedef boost::ulong_long_type const type; }; template<> struct promote_from_index<6,1,1> { typedef boost::ulong_long_type const volatile type; };
># 120 "/usr/include/boost/type_traits/integral_promotion.hpp" 3 4
>template<int N>
>struct sized_type_for_promotion
>{
> typedef char (&type)[N];
>};
># 136 "/usr/include/boost/type_traits/integral_promotion.hpp" 3 4
>sized_type_for_promotion<1>::type promoted_index_tester(int);
>sized_type_for_promotion<2>::type promoted_index_tester(unsigned int);
>sized_type_for_promotion<3>::type promoted_index_tester(long);
>sized_type_for_promotion<4>::type promoted_index_tester(unsigned long);
>
>
>sized_type_for_promotion<5>::type promoted_index_tester(boost::long_long_type);
>sized_type_for_promotion<6>::type promoted_index_tester(boost::ulong_long_type);
># 154 "/usr/include/boost/type_traits/integral_promotion.hpp" 3 4
>template<class T>
>struct promoted_index
>{
> static T testee;
> static const int value = sizeof(promoted_index_tester(+testee));
>
>};
>
>template<class T>
>struct integral_promotion_impl
>{
> typedef typename promote_from_index<
> (boost::type_traits::detail::promoted_index<T>::value)
> , (boost::is_const<T>::value)
> , (boost::is_volatile<T>::value)
> >::type type;
>};
>
>template<class T>
>struct integral_promotion
> : public boost::mpl::eval_if<
> need_promotion<typename remove_cv<T>::type>
> , integral_promotion_impl<T>
> , boost::mpl::identity<T>
> >
>{
>};
>
>} }
>
>template< typename T > struct integral_promotion { public: typedef typename boost::type_traits::detail::integral_promotion<T>::type type; };
>
>
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 193 "/usr/include/boost/type_traits/integral_promotion.hpp" 2 3 4
># 95 "/usr/include/boost/type_traits.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/promote.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/promote.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 15 "/usr/include/boost/type_traits/promote.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
>
>template<class T>
>struct promote_impl
> : public integral_promotion<
> typename floating_point_promotion<T>::type
> >
>{
>};
>
>}
>
>template< typename T > struct promote { public: typedef typename boost::detail::promote_impl<T>::type type; };
>
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 38 "/usr/include/boost/type_traits/promote.hpp" 2 3 4
># 96 "/usr/include/boost/type_traits.hpp" 2 3 4
># 31 "/usr/include/boost/multi_array.hpp" 2 3 4
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 33 "/usr/include/boost/multi_array.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost {
> namespace detail {
> namespace multi_array {
>
> struct populate_index_ranges {
> multi_array_types::index_range
>
> operator()(multi_array_types::index base,
> multi_array_types::size_type extent_) {
> return multi_array_types::index_range(base,base+extent_);
> }
> };
># 106 "/usr/include/boost/multi_array.hpp" 3 4
> }
> }
>
>template<typename T, std::size_t NumDims,
> typename Allocator>
>class multi_array :
> public multi_array_ref<T,NumDims>
>{
> typedef multi_array_ref<T,NumDims> super_type;
>public:
> typedef typename super_type::value_type value_type;
> typedef typename super_type::reference reference;
> typedef typename super_type::const_reference const_reference;
> typedef typename super_type::iterator iterator;
> typedef typename super_type::const_iterator const_iterator;
> typedef typename super_type::reverse_iterator reverse_iterator;
> typedef typename super_type::const_reverse_iterator const_reverse_iterator;
> typedef typename super_type::element element;
> typedef typename super_type::size_type size_type;
> typedef typename super_type::difference_type difference_type;
> typedef typename super_type::index index;
> typedef typename super_type::extent_range extent_range;
>
>
> template <std::size_t NDims>
> struct const_array_view {
> typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
> };
>
> template <std::size_t NDims>
> struct array_view {
> typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
> };
>
> explicit multi_array() :
> super_type((T*)initial_base_,c_storage_order(),
> 0, 0) {
> allocate_space();
> }
>
> template <class ExtentList>
> explicit multi_array(
> ExtentList const& extents
>
>
>
>
>
> ) :
> super_type((T*)initial_base_,extents) {
> boost::function_requires<
> detail::multi_array::CollectionConcept<ExtentList> >();
> allocate_space();
> }
>
>
> template <class ExtentList>
> explicit multi_array(ExtentList const& extents,
> const general_storage_order<NumDims>& so) :
> super_type((T*)initial_base_,extents,so) {
> boost::function_requires<
> detail::multi_array::CollectionConcept<ExtentList> >();
> allocate_space();
> }
>
> template <class ExtentList>
> explicit multi_array(ExtentList const& extents,
> const general_storage_order<NumDims>& so,
> Allocator const& alloc) :
> super_type((T*)initial_base_,extents,so), allocator_(alloc) {
> boost::function_requires<
> detail::multi_array::CollectionConcept<ExtentList> >();
> allocate_space();
> }
>
>
> explicit multi_array(const detail::multi_array
> ::extent_gen<NumDims>& ranges) :
> super_type((T*)initial_base_,ranges) {
>
> allocate_space();
> }
>
>
> explicit multi_array(const detail::multi_array
> ::extent_gen<NumDims>& ranges,
> const general_storage_order<NumDims>& so) :
> super_type((T*)initial_base_,ranges,so) {
>
> allocate_space();
> }
>
>
> explicit multi_array(const detail::multi_array
> ::extent_gen<NumDims>& ranges,
> const general_storage_order<NumDims>& so,
> Allocator const& alloc) :
> super_type((T*)initial_base_,ranges,so), allocator_(alloc) {
>
> allocate_space();
> }
>
> multi_array(const multi_array& rhs) :
> super_type(rhs), allocator_(rhs.allocator_) {
> allocate_space();
> boost::detail::multi_array::copy_n(rhs.base_,rhs.num_elements(),base_);
> }
># 224 "/usr/include/boost/multi_array.hpp" 3 4
> template <typename OPtr>
> multi_array(const const_multi_array_ref<T,NumDims,OPtr>& rhs,
> const general_storage_order<NumDims>& so = c_storage_order())
> : super_type(0,so,rhs.index_bases(),rhs.shape())
> {
> allocate_space();
>
> std::copy(rhs.begin(),rhs.end(),this->begin());
> }
>
> template <typename OPtr>
> multi_array(const detail::multi_array::
> const_sub_array<T,NumDims,OPtr>& rhs,
> const general_storage_order<NumDims>& so = c_storage_order())
> : super_type(0,so,rhs.index_bases(),rhs.shape())
> {
> allocate_space();
> std::copy(rhs.begin(),rhs.end(),this->begin());
> }
>
>
> template <typename OPtr>
> multi_array(const detail::multi_array::
> const_multi_array_view<T,NumDims,OPtr>& rhs,
> const general_storage_order<NumDims>& so = c_storage_order())
> : super_type(0,so,rhs.index_bases(),rhs.shape())
> {
> allocate_space();
> std::copy(rhs.begin(),rhs.end(),this->begin());
> }
># 314 "/usr/include/boost/multi_array.hpp" 3 4
> multi_array(const multi_array_ref<T,NumDims>& rhs)
> : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape())
> {
> allocate_space();
>
> std::copy(rhs.begin(),rhs.end(),this->begin());
> }
>
> multi_array(const multi_array_ref<T,NumDims>& rhs,
> const general_storage_order<NumDims>& so)
> : super_type(0,so,rhs.index_bases(),rhs.shape())
> {
> allocate_space();
>
> std::copy(rhs.begin(),rhs.end(),this->begin());
> }
>
>
> multi_array(const detail::multi_array::
> sub_array<T,NumDims>& rhs)
> : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape())
> {
> allocate_space();
> std::copy(rhs.begin(),rhs.end(),this->begin());
> }
>
> multi_array(const detail::multi_array::
> sub_array<T,NumDims>& rhs,
> const general_storage_order<NumDims>& so)
> : super_type(0,so,rhs.index_bases(),rhs.shape())
> {
> allocate_space();
> std::copy(rhs.begin(),rhs.end(),this->begin());
> }
>
>
> multi_array(const detail::multi_array::
> multi_array_view<T,NumDims>& rhs)
> : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape())
> {
> allocate_space();
> std::copy(rhs.begin(),rhs.end(),this->begin());
> }
>
> multi_array(const detail::multi_array::
> multi_array_view<T,NumDims>& rhs,
> const general_storage_order<NumDims>& so)
> : super_type(0,so,rhs.index_bases(),rhs.shape())
> {
> allocate_space();
> std::copy(rhs.begin(),rhs.end(),this->begin());
> }
>
>
>
> template <typename ConstMultiArray>
> multi_array& operator=(const ConstMultiArray& other) {
> super_type::operator=(other);
> return *this;
> }
>
> multi_array& operator=(const multi_array& other) {
> if (&other != this) {
> super_type::operator=(other);
> }
> return *this;
> }
>
>
> template <typename ExtentList>
> multi_array& resize(const ExtentList& extents) {
> boost::function_requires<
> detail::multi_array::CollectionConcept<ExtentList> >();
>
> typedef detail::multi_array::extent_gen<NumDims> gen_type;
> gen_type ranges;
>
> for (int i=0; i != NumDims; ++i) {
> typedef typename gen_type::range range_type;
> ranges.ranges_[i] = range_type(0,extents[i]);
> }
>
> return this->resize(ranges);
> }
>
>
>
> multi_array& resize(const detail::multi_array
> ::extent_gen<NumDims>& ranges) {
>
>
>
> multi_array new_array(ranges,this->storage_order());
>
>
>
>
>
> boost::array<size_type,NumDims> min_extents;
>
> const size_type& (*min)(const size_type&, const size_type&) =
> std::min;
> std::transform(new_array.extent_list_.begin(),new_array.extent_list_.end(),
> this->extent_list_.begin(),
> min_extents.begin(),
> min);
>
>
>
>
>
>
> typedef detail::multi_array::index_gen<NumDims,NumDims> index_gen;
> index_gen old_idxes;
> index_gen new_idxes;
>
> std::transform(new_array.index_base_list_.begin(),
> new_array.index_base_list_.end(),
> min_extents.begin(),new_idxes.ranges_.begin(),
> detail::multi_array::populate_index_ranges());
>
> std::transform(this->index_base_list_.begin(),
> this->index_base_list_.end(),
> min_extents.begin(),old_idxes.ranges_.begin(),
> detail::multi_array::populate_index_ranges());
>
>
> typename
> multi_array::template array_view<NumDims>::type view_old = (*this)[old_idxes];
> typename
> multi_array::template array_view<NumDims>::type view_new = new_array[new_idxes];
>
>
> view_new = view_old;
>
> using std::swap;
>
> swap(this->super_type::base_,new_array.super_type::base_);
> swap(this->storage_,new_array.storage_);
> swap(this->extent_list_,new_array.extent_list_);
> swap(this->stride_list_,new_array.stride_list_);
> swap(this->index_base_list_,new_array.index_base_list_);
> swap(this->origin_offset_,new_array.origin_offset_);
> swap(this->directional_offset_,new_array.directional_offset_);
> swap(this->num_elements_,new_array.num_elements_);
> swap(this->allocator_,new_array.allocator_);
> swap(this->base_,new_array.base_);
> swap(this->allocated_elements_,new_array.allocated_elements_);
>
> return *this;
> }
>
>
> ~multi_array() {
> deallocate_space();
> }
>
>private:
> void allocate_space() {
> typename Allocator::const_pointer no_hint=0;
> base_ = allocator_.allocate(this->num_elements(),no_hint);
> this->set_base_ptr(base_);
> allocated_elements_ = this->num_elements();
> std::uninitialized_fill_n(base_,allocated_elements_,T());
> }
>
> void deallocate_space() {
> if(base_) {
> for(T* i = base_; i != base_+allocated_elements_; ++i)
> allocator_.destroy(i);
> allocator_.deallocate(base_,allocated_elements_);
> }
> }
>
> typedef boost::array<size_type,NumDims> size_list;
> typedef boost::array<index,NumDims> index_list;
>
> Allocator allocator_;
> T* base_;
> size_type allocated_elements_;
> enum {initial_base_ = 0};
>};
>
>}
># 29 "../src/detect.h" 2
>
>
>
>
>const uint32_t defSearchSignalLength1 = 256;
>const uint32_t defSearchSignalPeakPos1 = 0;
>const double defSearchSignal1[defSearchSignalLength1] =
>{
> +0.055,+0.135,+0.266,+0.413,+0.569,+0.720,+0.851,+0.947,+0.999,+1.000,+0.913,+0.786,+0.632,+0.463,+0.294,+0.139,
> +0.008,-0.093,-0.137,-0.155,-0.151,-0.132,-0.105,-0.075,-0.046,-0.021,-0.009,-0.004,-0.003,-0.008,-0.014,-0.021,
> -0.026,-0.030,-0.027,-0.022,-0.015,-0.007,+0.000,+0.007,+0.012,+0.013,+0.009,+0.003,-0.005,-0.013,-0.022,-0.029,
> -0.034,-0.037,-0.036,-0.032,-0.028,-0.022,-0.016,-0.011,-0.006,-0.003,-0.002,-0.002,-0.003,-0.005,-0.006,-0.007,
> -0.008,-0.007,-0.005,-0.002,+0.001,+0.004,+0.007,+0.010,+0.011,+0.012,+0.012,+0.011,+0.009,+0.007,+0.005,+0.004,
> +0.003,+0.004,+0.006,+0.009,+0.012,+0.016,+0.018,+0.020,+0.019,+0.017,+0.012,+0.005,-0.003,-0.012,-0.020,-0.026,
> -0.031,-0.034,-0.033,-0.030,-0.026,-0.021,-0.016,-0.012,-0.008,-0.006,-0.006,-0.007,-0.009,-0.010,-0.012,-0.012,
> -0.012,-0.009,-0.004,+0.002,+0.009,+0.017,+0.024,+0.029,+0.032,+0.033,+0.029,+0.023,+0.016,+0.009,+0.001,-0.006,
> -0.012,-0.017,-0.018,-0.018,-0.017,-0.016,-0.013,-0.010,-0.006,-0.009,-0.012,-0.013,-0.014,-0.015,-0.014,-0.012,
> -0.009,-0.005,+0.001,+0.008,+0.016,+0.022,+0.028,+0.032,+0.034,+0.034,+0.029,+0.023,+0.015,+0.007,-0.001,-0.008,
> -0.014,-0.018,-0.019,-0.018,-0.017,-0.015,-0.013,-0.011,-0.010,-0.010,-0.011,-0.014,-0.017,-0.020,-0.023,-0.025,
> -0.025,-0.024,-0.019,-0.013,-0.006,+0.002,+0.009,+0.016,+0.021,+0.024,+0.024,+0.022,+0.019,+0.014,+0.010,+0.006,
> +0.003,+0.001,+0.001,+0.001,+0.003,+0.005,+0.007,+0.008,+0.009,+0.009,+0.008,+0.006,+0.004,+0.001,-0.002,-0.005,
> -0.007,-0.009,-0.009,-0.010,-0.010,-0.009,-0.009,-0.009,-0.010,-0.011,-0.014,-0.018,-0.022,-0.026,-0.029,-0.032,
> -0.032,-0.031,-0.025,-0.018,-0.010,-0.002,+0.004,+0.009,+0.012,+0.011,+0.005,-0.003,-0.012,-0.022,-0.031,-0.039,
> -0.045,-0.049,-0.049,-0.046,-0.043,-0.038,-0.034,-0.030,-0.027,-0.026,-0.036,-0.044,-0.050,-0.050,-0.036,-0.002
>};
>
>const uint32_t defSearchSignalLength = 128;
>const uint32_t defSearchSignalPeakPos = 10;
>const double defSearchSignal[defSearchSignalLength] =
>{
> +0.0546,+0.1353,+0.2665,+0.4134,+0.5686,+0.7199,+0.8511,+0.9474,
> +0.9987,+1.0000,+0.9126,+0.7862,+0.6316,+0.4626,+0.2941,+0.1391,
> +0.0080,-0.0931,-0.1371,-0.1547,-0.1508,-0.1319,-0.1048,-0.0749,
> -0.0459,-0.0213,-0.0092,-0.0036,-0.0035,-0.0076,-0.0140,-0.0206,
> -0.0262,-0.0297,-0.0273,-0.0222,-0.0152,-0.0073,+0.0005,+0.0071,
> +0.0116,+0.0133,+0.0093,+0.0031,-0.0048,-0.0134,-0.0217,-0.0288,
> -0.0341,-0.0372,-0.0358,-0.0325,-0.0277,-0.0220,-0.0161,-0.0106,
> -0.0060,-0.0026,-0.0020,-0.0023,-0.0033,-0.0047,-0.0061,-0.0072,
> -0.0076,-0.0072,-0.0051,-0.0024,+0.0008,+0.0040,+0.0071,+0.0097,
> +0.0115,+0.0093,+0.0080,+0.0061,+0.0037,+0.0009,-0.0020,-0.0047,
> -0.0068,-0.0086,-0.0094,-0.0097,-0.0096,-0.0092,-0.0088,-0.0089,
> -0.0097,-0.0113,-0.0141,-0.0176,-0.0217,-0.0259,-0.0294,-0.0317,
> -0.0323,-0.0309,-0.0252,-0.0182,-0.0103,-0.0024,+0.0045,+0.0094,
> +0.0119,+0.0115,+0.0054,-0.0026,-0.0119,-0.0217,-0.0311,-0.0391,
> -0.0453,-0.0492,-0.0486,-0.0463,-0.0426,-0.0382,-0.0338,-0.0300,
> -0.0274,-0.0261,-0.0358,-0.0443,-0.0504,-0.0499,-0.0356,-0.0019
>};
>
>
>
>template < class T > class ringVector:public std::vector<T>
>{
>public:
> ringVector():std::vector<T>::vector() {};
> ringVector(uint32_t s):std::vector<T>::vector(s) {};
> ringVector(uint32_t s, T &v):std::vector<T>::vector(s, v) {};
> T &operator [](int x)
> {
> int ax = x % std::vector<T>::size();
> if (ax < 0) ax += std::vector<T>::size();
> return std::vector<T>::operator[](ax);
> }
> T &operator [](uint32_t x)
> {
> return operator[](int(x));
> }
>};
>
>typedef std::complex<double> cplx;
>
>class signalDetect
>{
>public:
> signalDetect(const uint32_t length, const uint32_t peak, const double *signal);
> bool setSignal(const uint32_t length, const uint32_t peak, const double *signal);
> double *findSignals(uint32_t inputLength, const cplx *input);
> uint32_t length(void) {return searchSignalLength;};
> uint32_t peak(void) {return searchSignalPeakPos;};
> double *signals(void) {return output;};
> double *searchSignal;
>private:
> double *output;
> uint32_t searchSignalLength;
> uint32_t searchSignalPeakPos;
> correlate *signalCorrelator;
> void initialiseSignal(const uint32_t length, const uint32_t peak, const double *signal);
>
>};
>
>
>
>uint32_t findPeak(uint32_t size, const cplx *input, bool abs = true);
>uint32_t findPeak(uint32_t size, const double *input, bool abs = true);
>uint32_t findPeak(uint32_t size, const float *input, bool abs = true);
>double rms(uint32_t size, const cplx *input);
>double rms(uint32_t size, const double *input);
>double rms(uint32_t size, const float *input);
>double acrms(uint32_t size, const cplx *input);
>double acrms(uint32_t size, const double *input);
>double acrms(uint32_t size, const uint16_t short *input);
>double adjustedRMS(uint32_t size, double max, const cplx *input);
>double adjustedRMS(uint32_t size, double max, const double *input);
>uint32_t findSecondPeak(uint32_t size, const cplx *input, uint32_t peak_pos, uint32_t min_dist = 1);
>uint32_t findSecondPeak(uint32_t size, const double *input, uint32_t peak_pos, uint32_t min_dist = 1, bool abs = true);
>double getPeakRatio(uint32_t size, cplx * input, uint32_t minDist, uint32_t startpoint = 8);
>double getSignalPeakRatio(uint32_t size, const double * input, uint32_t &signalStart, uint32_t &signalEnd);
>
>
>
>
>
>struct blownOptimiser
>{
> int val;
> blownOptimiser(int v):val(v){};
>};
>
>const blownOptimiser kmovementInvalid(73);
>const blownOptimiser kvalueInvalid(74);
>
>
>
>const uint32_t dcDefSize(defSearchSignalLength);
>typedef float dcValueType;
>
>
>
>static inline bool isValid(const dcValueType inNumber){return (__finite(inNumber));};
>
>
>
>
>typedef boost::multi_array<dcValueType, 2> dcMatrix;
>
>
>
>typedef std::vector<dcValueType> dcArray;
>
>
>
>typedef ringVector<dcValueType> dcRingVector;
>
>
>
>struct oneRefData_t
>{
> tpower power;
> rgain gain;
> rbw bandwidth;
> uint32_t peakPos;
> uint32_t length;
> double *data;
>
> ~oneRefData_t() {delete data;};
>};
>typedef std::vector<oneRefData_t> allRefData_t;
>
>const uint32_t cdCheckingLoops = 40;
>
>
>
>const double defMinCorrection = 0.125;
>const uint32_t defCorrectionOffset = 1;
>const double defMaxDetectDistance = 3000;
>const double defMinDetectDistance = 0;
>const double defMaxCorrectDistance = 625;
>const double defMaxDeconvDistance = 6000;
>const double rmsToPeakAdjustment = 2.2;
>
>
>
>class deconvolver
>{
>private:
> sint32_t size;
> sint32_t referenceEffectiveLength;
> bool signalValid;
> bool referenceValid;
> dcMatrix allResidues;
> dcRingVector signal;
> dcRingVector deconvolution;
> dcRingVector timeResidues;
> dcRingVector reference;
> double *result;
> double *correctedResult;
> uint32_t zeroPos;
> uint32_t optLoops;
> dcValueType rssReference;
> dcValueType deconValueLimit;
> dcValueType minCorrectionValue;
> dcValueType correctionMaxDistance;
> uint32_t correctionDistanceAdjustment;
> dcValueType deconvolutionDetectionReference;
> pointState currentPointState;
> allRefData_t *allRefData;
> dcValueType ORfactor;
>
>public:
> deconvolver(sint32_t s);
> ~deconvolver();
> void setReferenceEffectiveLength(sint32_t el);
> sint32_t getReferenceEffectiveLength(void){return referenceEffectiveLength;};
> void setSignal(const double *s);
> void setReference(const double *r);
> void setCorrectionParameters(dcValueType minCorr, dcValueType maxDistance, uint32_t distAdjustment);
> void setLoops(uint32_t l);
> uint32_t getLoops(void) {return optLoops;};
> double *deconvolve(const double *input);
> dcValueType totalError(sint32_t pos);
> bool optimiseDeconvolution(sint32_t pos, dcValueType s);
> void calcResidues();
> void updateResidues(sint32_t pos);
> dcValueType fullError();
> sint32_t getSize() {return size;};
> dcValueType getReferenceRSS() {return rssReference;};
> uint32_t getZeroPos() {return zeroPos;};
> void setZeroPos(uint32_t p) {zeroPos = p;};
> dcValueType getDCRefValue() {return deconvolutionDetectionReference;};
> void setDCRefValue(dcValueType r) {deconvolutionDetectionReference = r;};
> double *getDeconvolution() {return result;};
> void correctDeconvolution();
> double *getCorrectedDeconvolution() {return correctedResult;};
> void setAllRefSignals(allRefData_t *rd);
> pointState getNearestState(pointState &state);
> bool setActiveState(pointState &state);
>};
># 20 "../src/measure.h" 2
>
>typedef uint32_t st;
>typedef std::vector<filterImplement> filterList;
>
>const uint32_t maxSingleRepeats = 4096;
>const uint32_t minCalDelay = 90;
>const uint32_t maxCalDelay = minCalDelay * 20;
>
>const double diodeDrop = 0.5;
>const double lightSpeed = 300000000;
>
>class measurementSettings
>{
>public:
>
> measurementSettings(st r, st rsc, st fsc, st dl, st mst, double dr, double ar, double cr, channels c, filterList fl, tpower p, rgain g, rbw bw);
> void setClasses(correlate *c, positioner *p, iWCCclass *i);
> void setDistanceCorrection(uint32_t co, double maxD, double minD, double maxC, double maxDD, double minC);
> void update(st r, st rsc, st fsc, st dl, st mst, double dr, double ar, double cr, channels c, filterList fl, tpower p, rgain g, rbw bw);
> void setArrays(double * r, double *f, double *ff, cplx* cs, cplx *c2);
>
> scanStatus status;
> uint32_t repeats;
> uint32_t rawSampleCount;
> uint32_t filteredSampleCount;
> uint32_t debugLevel;
> uint32_t maxScanTime;
> uint32_t correlationZeroPoint;
> double detectionRatio;
> double alarmRatio;
> uint32_t correctionOffset;
> double maxDetectDistance;
> double minDetectDistance;
> double maxCorrectDistance;
> double maxDeconvDistance;
> double minCorrection;
> double measuredRatio;
> double codeRate;
> channels channel;
> bool saturated;
> correlate *correlation;
> iWCCclass *iWCC;
> positioner *positioning;
> signalDetect *detector;
> deconvolver *deconvolving;
> std::vector<filterImplement> filters;
> tpower power;
> rgain gain;
> rbw bandwidth;
> double *rawData;
> double *filteredData;
> double *fftData;
> cplx *correlationSum;
> cplx *correlation2;
> time_t lastCalTime;
>};
>
>float *captureOnce(measurementSettings &settings);
>bool measureOnce(measurementSettings &settings, pointData *result = 0, bool inScan = false);
>bool processMeasurement(measurementSettings &settings, pointData &pd, const float *data);
>bool scan(measurementSettings &settings);
>void doDetected(wildfireStatus &stats, measurementSettings &settings, std::string *timeStamp);
># 16 "../src/wildfire.cpp" 2
>
># 1 "../src/correlation.h" 1
># 18 "../src/wildfire.cpp" 2
>
># 1 "../src/commands.h" 1
># 21 "../src/commands.h"
># 1 "/usr/include/boost/asio.hpp" 1 3 4
># 20 "/usr/include/boost/asio.hpp" 3 4
># 1 "/usr/include/boost/asio/async_result.hpp" 1 3 4
># 18 "/usr/include/boost/asio/async_result.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/config.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/config.hpp" 3 4
># 1 "/usr/include/boost/version.hpp" 1 3 4
># 28 "/usr/include/boost/asio/detail/config.hpp" 2 3 4
># 431 "/usr/include/boost/asio/detail/config.hpp" 3 4
># 1 "/usr/include/linux/version.h" 1 3 4
># 432 "/usr/include/boost/asio/detail/config.hpp" 2 3 4
># 19 "/usr/include/boost/asio/async_result.hpp" 2 3 4
># 1 "/usr/include/boost/asio/handler_type.hpp" 1 3 4
># 20 "/usr/include/boost/asio/handler_type.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 21 "/usr/include/boost/asio/handler_type.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 34 "/usr/include/boost/asio/handler_type.hpp" 3 4
>template <typename Handler, typename Signature>
>struct handler_type
>{
>
> typedef Handler type;
>};
>
>
>
>template <typename Handler, typename Signature>
>struct handler_type<const Handler, Signature>
> : handler_type<Handler, Signature> {};
>
>template <typename Handler, typename Signature>
>struct handler_type<volatile Handler, Signature>
> : handler_type<Handler, Signature> {};
>
>template <typename Handler, typename Signature>
>struct handler_type<const volatile Handler, Signature>
> : handler_type<Handler, Signature> {};
>
>template <typename Handler, typename Signature>
>struct handler_type<const Handler&, Signature>
> : handler_type<Handler, Signature> {};
>
>template <typename Handler, typename Signature>
>struct handler_type<volatile Handler&, Signature>
> : handler_type<Handler, Signature> {};
>
>template <typename Handler, typename Signature>
>struct handler_type<const volatile Handler&, Signature>
> : handler_type<Handler, Signature> {};
>
>template <typename Handler, typename Signature>
>struct handler_type<Handler&, Signature>
> : handler_type<Handler, Signature> {};
>
>
>template <typename Handler, typename Signature>
>struct handler_type<Handler&&, Signature>
> : handler_type<Handler, Signature> {};
>
>
>template <typename ReturnType, typename Signature>
>struct handler_type<ReturnType(), Signature>
> : handler_type<ReturnType(*)(), Signature> {};
>
>template <typename ReturnType, typename Arg1, typename Signature>
>struct handler_type<ReturnType(Arg1), Signature>
> : handler_type<ReturnType(*)(Arg1), Signature> {};
>
>template <typename ReturnType, typename Arg1, typename Arg2, typename Signature>
>struct handler_type<ReturnType(Arg1, Arg2), Signature>
> : handler_type<ReturnType(*)(Arg1, Arg2), Signature> {};
>
>template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
> typename Signature>
>struct handler_type<ReturnType(Arg1, Arg2, Arg3), Signature>
> : handler_type<ReturnType(*)(Arg1, Arg2, Arg3), Signature> {};
>
>template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
> typename Arg4, typename Signature>
>struct handler_type<ReturnType(Arg1, Arg2, Arg3, Arg4), Signature>
> : handler_type<ReturnType(*)(Arg1, Arg2, Arg3, Arg4), Signature> {};
>
>template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
> typename Arg4, typename Arg5, typename Signature>
>struct handler_type<ReturnType(Arg1, Arg2, Arg3, Arg4, Arg5), Signature>
> : handler_type<ReturnType(*)(Arg1, Arg2, Arg3, Arg4, Arg5), Signature> {};
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 110 "/usr/include/boost/asio/handler_type.hpp" 2 3 4
># 20 "/usr/include/boost/asio/async_result.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/async_result.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>
>
>
>template <typename Handler>
>class async_result
>{
>public:
>
> typedef void type;
>
>
>
>
>
>
>
> explicit async_result(Handler&)
> {
> }
>
>
> type get()
> {
> }
>};
>
>namespace detail {
>
>
>
>template <typename Handler, typename Signature>
>struct async_result_init
>{
> explicit async_result_init(Handler&& orig_handler)
> : handler(static_cast<Handler&&>(orig_handler)),
> result(handler)
> {
> }
>
> typename handler_type<Handler, Signature>::type handler;
> async_result<typename handler_type<Handler, Signature>::type> result;
>};
>
>template <typename Handler, typename Signature>
>struct async_result_type_helper
>{
> typedef typename async_result<
> typename handler_type<Handler, Signature>::type
> >::type type;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 83 "/usr/include/boost/asio/async_result.hpp" 2 3 4
># 21 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_datagram_socket.hpp" 1 3 4
># 19 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/basic_datagram_socket.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_socket.hpp" 1 3 4
># 20 "/usr/include/boost/asio/basic_socket.hpp" 3 4
># 1 "/usr/include/boost/asio/basic_io_object.hpp" 1 3 4
># 19 "/usr/include/boost/asio/basic_io_object.hpp" 3 4
># 1 "/usr/include/boost/asio/io_service.hpp" 1 3 4
># 19 "/usr/include/boost/asio/io_service.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/io_service.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/noncopyable.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/noncopyable.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/noncopyable.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class noncopyable
>{
>protected:
> noncopyable() {}
> ~noncopyable() {}
>private:
> noncopyable(const noncopyable&);
> const noncopyable& operator=(const noncopyable&);
>};
>
>}
>
>using boost::asio::detail::noncopyable;
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 44 "/usr/include/boost/asio/detail/noncopyable.hpp" 2 3 4
># 24 "/usr/include/boost/asio/io_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/service_registry_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/asio/detail/service_registry_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>class service_registry;
>
>}
>}
>}
># 25 "/usr/include/boost/asio/io_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/wrapped_handler.hpp" 1 3 4
># 18 "/usr/include/boost/asio/detail/wrapped_handler.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/bind_handler.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/bind_handler.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/handler_alloc_helpers.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/handler_alloc_helpers.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/addressof.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/addressof.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>using std::addressof;
>
>
>
>
>}
>}
>}
># 20 "/usr/include/boost/asio/detail/handler_alloc_helpers.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/handler_alloc_hook.hpp" 1 3 4
># 19 "/usr/include/boost/asio/handler_alloc_hook.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/handler_alloc_hook.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/handler_alloc_hook.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 58 "/usr/include/boost/asio/handler_alloc_hook.hpp" 3 4
>inline void* asio_handler_allocate(
> std::size_t size, ...);
># 71 "/usr/include/boost/asio/handler_alloc_hook.hpp" 3 4
>inline void asio_handler_deallocate(
> void* pointer, std::size_t size, ...);
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 78 "/usr/include/boost/asio/handler_alloc_hook.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/impl/handler_alloc_hook.ipp" 1 3 4
># 19 "/usr/include/boost/asio/impl/handler_alloc_hook.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/call_stack.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/call_stack.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/tss_ptr.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/tss_ptr.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/keyword_tss_ptr.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/keyword_tss_ptr.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/keyword_tss_ptr.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename T>
>class keyword_tss_ptr
> : private noncopyable
>{
>public:
>
> keyword_tss_ptr()
> {
> }
>
>
> ~keyword_tss_ptr()
> {
> }
>
>
> operator T*() const
> {
> return value_;
> }
>
>
> void operator=(T* value)
> {
> value_ = value;
> }
>
>private:
> static __thread T* value_;
>};
>
>template <typename T>
>__thread T* keyword_tss_ptr<T>::value_;
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 69 "/usr/include/boost/asio/detail/keyword_tss_ptr.hpp" 2 3 4
># 24 "/usr/include/boost/asio/detail/tss_ptr.hpp" 2 3 4
># 32 "/usr/include/boost/asio/detail/tss_ptr.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 33 "/usr/include/boost/asio/detail/tss_ptr.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename T>
>class tss_ptr
>
>
>
> : public keyword_tss_ptr<T>
>
>
>
>
>
>{
>public:
> void operator=(T* value)
> {
>
>
>
> keyword_tss_ptr<T>::operator=(value);
>
>
>
>
>
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 70 "/usr/include/boost/asio/detail/tss_ptr.hpp" 2 3 4
># 21 "/usr/include/boost/asio/detail/call_stack.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/call_stack.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>template <typename Key, typename Value = unsigned char>
>class call_stack
>{
>public:
>
> class context
> : private noncopyable
> {
> public:
>
> explicit context(Key* k)
> : key_(k),
> next_(call_stack<Key, Value>::top_)
> {
> value_ = reinterpret_cast<unsigned char*>(this);
> call_stack<Key, Value>::top_ = this;
> }
>
>
> context(Key* k, Value& v)
> : key_(k),
> value_(&v),
> next_(call_stack<Key, Value>::top_)
> {
> call_stack<Key, Value>::top_ = this;
> }
>
>
> ~context()
> {
> call_stack<Key, Value>::top_ = next_;
> }
>
>
> Value* next_by_key() const
> {
> context* elem = next_;
> while (elem)
> {
> if (elem->key_ == key_)
> return elem->value_;
> elem = elem->next_;
> }
> return 0;
> }
>
> private:
> friend class call_stack<Key, Value>;
>
>
> Key* key_;
>
>
> Value* value_;
>
>
> context* next_;
> };
>
> friend class context;
>
>
>
> static Value* contains(Key* k)
> {
> context* elem = top_;
> while (elem)
> {
> if (elem->key_ == k)
> return elem->value_;
> elem = elem->next_;
> }
> return 0;
> }
>
>
> static Value* top()
> {
> context* elem = top_;
> return elem ? elem->value_ : 0;
> }
>
>private:
>
> static tss_ptr<context> top_;
>};
>
>template <typename Key, typename Value>
>tss_ptr<typename call_stack<Key, Value>::context>
>call_stack<Key, Value>::top_;
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 126 "/usr/include/boost/asio/detail/call_stack.hpp" 2 3 4
># 20 "/usr/include/boost/asio/impl/handler_alloc_hook.ipp" 2 3 4
># 1 "/usr/include/boost/asio/handler_alloc_hook.hpp" 1 3 4
># 21 "/usr/include/boost/asio/impl/handler_alloc_hook.ipp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/task_io_service_thread_info.hpp" 1 3 4
># 18 "/usr/include/boost/asio/detail/task_io_service_thread_info.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/event.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/event.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_event.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/posix_event.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/assert.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/assert.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/assert.hpp" 2 3 4
># 24 "/usr/include/boost/asio/detail/posix_event.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/posix_event.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class posix_event
> : private noncopyable
>{
>public:
>
> inline posix_event();
>
>
> ~posix_event()
> {
> ::pthread_cond_destroy(&cond_);
> }
>
>
> template <typename Lock>
> void signal(Lock& lock)
> {
> ((void)0);
> (void)lock;
> signalled_ = true;
> ::pthread_cond_signal(&cond_);
> }
>
>
> template <typename Lock>
> void signal_and_unlock(Lock& lock)
> {
> ((void)0);
> signalled_ = true;
> lock.unlock();
> ::pthread_cond_signal(&cond_);
> }
>
>
> template <typename Lock>
> void clear(Lock& lock)
> {
> ((void)0);
> (void)lock;
> signalled_ = false;
> }
>
>
> template <typename Lock>
> void wait(Lock& lock)
> {
> ((void)0);
> while (!signalled_)
> ::pthread_cond_wait(&cond_, &lock.mutex().mutex_);
> }
>
>private:
> ::pthread_cond_t cond_;
> bool signalled_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 93 "/usr/include/boost/asio/detail/posix_event.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/posix_event.ipp" 1 3 4
># 22 "/usr/include/boost/asio/detail/impl/posix_event.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_event.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/impl/posix_event.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/throw_error.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/throw_error.hpp" 3 4
># 1 "/usr/include/boost/system/error_code.hpp" 1 3 4
># 14 "/usr/include/boost/system/error_code.hpp" 3 4
># 1 "/usr/include/boost/system/config.hpp" 1 3 4
># 14 "/usr/include/boost/system/config.hpp" 3 4
># 1 "/usr/include/boost/system/api_config.hpp" 1 3 4
># 15 "/usr/include/boost/system/config.hpp" 2 3 4
># 65 "/usr/include/boost/system/config.hpp" 3 4
># 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
># 66 "/usr/include/boost/system/config.hpp" 2 3 4
># 15 "/usr/include/boost/system/error_code.hpp" 2 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 108 "/usr/include/boost/cstdint.hpp" 3 4
>namespace boost
>{
>
> using ::int8_t;
> using ::int_least8_t;
> using ::int_fast8_t;
> using ::uint8_t;
> using ::uint_least8_t;
> using ::uint_fast8_t;
>
> using ::int16_t;
> using ::int_least16_t;
> using ::int_fast16_t;
> using ::uint16_t;
> using ::uint_least16_t;
> using ::uint_fast16_t;
>
> using ::int32_t;
> using ::int_least32_t;
> using ::int_fast32_t;
> using ::uint32_t;
> using ::uint_least32_t;
> using ::uint_fast32_t;
>
>
>
> using ::int64_t;
> using ::int_least64_t;
> using ::int_fast64_t;
> using ::uint64_t;
> using ::uint_least64_t;
> using ::uint_fast64_t;
>
>
>
> using ::intmax_t;
> using ::uintmax_t;
>
>}
># 16 "/usr/include/boost/system/error_code.hpp" 2 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 17 "/usr/include/boost/system/error_code.hpp" 2 3 4
># 1 "/usr/include/boost/operators.hpp" 1 3 4
># 97 "/usr/include/boost/operators.hpp" 3 4
>namespace boost {
>namespace detail {
>
>template <typename T> class empty_base {
>
>
>
>
>
>
>};
>
>}
>}
># 120 "/usr/include/boost/operators.hpp" 3 4
>namespace boost
>{
>
>
>
>
>
>
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct less_than_comparable2 : B
>{
> friend bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); }
> friend bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); }
> friend bool operator>(const U& x, const T& y) { return y < x; }
> friend bool operator<(const U& x, const T& y) { return y > x; }
> friend bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); }
> friend bool operator>=(const U& x, const T& y) { return !static_cast<bool>(y > x); }
>};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct less_than_comparable1 : B
>{
> friend bool operator>(const T& x, const T& y) { return y < x; }
> friend bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
> friend bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
>};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct equality_comparable2 : B
>{
> friend bool operator==(const U& y, const T& x) { return x == y; }
> friend bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); }
> friend bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); }
>};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct equality_comparable1 : B
>{
> friend bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); }
>};
># 256 "/usr/include/boost/operators.hpp" 3 4
>template <class T, class U, class B = ::boost::detail::empty_base<T> > struct multipliable2 : B { friend T operator *( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv *= rhs; return nrv; } friend T operator *( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv *= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct multipliable1 : B { friend T operator *( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv *= rhs; return nrv; } };
>template <class T, class U, class B = ::boost::detail::empty_base<T> > struct addable2 : B { friend T operator +( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv += rhs; return nrv; } friend T operator +( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv += lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct addable1 : B { friend T operator +( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv += rhs; return nrv; } };
>template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2 : B { friend T operator -( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2_left : B { friend T operator -( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct subtractable1 : B { friend T operator -( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } };
>template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2 : B { friend T operator /( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2_left : B { friend T operator /( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct dividable1 : B { friend T operator /( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } };
>template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2 : B { friend T operator %( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2_left : B { friend T operator %( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct modable1 : B { friend T operator %( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } };
>template <class T, class U, class B = ::boost::detail::empty_base<T> > struct xorable2 : B { friend T operator ^( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv ^= rhs; return nrv; } friend T operator ^( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv ^= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct xorable1 : B { friend T operator ^( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv ^= rhs; return nrv; } };
>template <class T, class U, class B = ::boost::detail::empty_base<T> > struct andable2 : B { friend T operator &( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv &= rhs; return nrv; } friend T operator &( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv &= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct andable1 : B { friend T operator &( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv &= rhs; return nrv; } };
>template <class T, class U, class B = ::boost::detail::empty_base<T> > struct orable2 : B { friend T operator |( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv |= rhs; return nrv; } friend T operator |( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv |= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct orable1 : B { friend T operator |( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv |= rhs; return nrv; } };
>
>
>
>
>
>
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct incrementable : B
>{
> friend T operator++(T& x, int)
> {
> incrementable_type nrv(x);
> ++x;
> return nrv;
> }
>private:
> typedef T incrementable_type;
>};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct decrementable : B
>{
> friend T operator--(T& x, int)
> {
> decrementable_type nrv(x);
> --x;
> return nrv;
> }
>private:
> typedef T decrementable_type;
>};
>
>
>
>template <class T, class P, class B = ::boost::detail::empty_base<T> >
>struct dereferenceable : B
>{
> P operator->() const
> {
> return &*static_cast<const T&>(*this);
> }
>};
>
>template <class T, class I, class R, class B = ::boost::detail::empty_base<T> >
>struct indexable : B
>{
> R operator[](I n) const
> {
> return *(static_cast<const T&>(*this) + n);
> }
>};
># 354 "/usr/include/boost/operators.hpp" 3 4
>template <class T, class U, class B = ::boost::detail::empty_base<T> > struct left_shiftable2 : B { friend T operator <<( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv <<= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct left_shiftable1 : B { friend T operator <<( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv <<= rhs; return nrv; } };
>template <class T, class U, class B = ::boost::detail::empty_base<T> > struct right_shiftable2 : B { friend T operator >>( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv >>= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct right_shiftable1 : B { friend T operator >>( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv >>= rhs; return nrv; } };
>
>
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct equivalent2 : B
>{
> friend bool operator==(const T& x, const U& y)
> {
> return !static_cast<bool>(x < y) && !static_cast<bool>(x > y);
> }
>};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct equivalent1 : B
>{
> friend bool operator==(const T&x, const T&y)
> {
> return !static_cast<bool>(x < y) && !static_cast<bool>(y < x);
> }
>};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct partially_ordered2 : B
>{
> friend bool operator<=(const T& x, const U& y)
> { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
> friend bool operator>=(const T& x, const U& y)
> { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
> friend bool operator>(const U& x, const T& y)
> { return y < x; }
> friend bool operator<(const U& x, const T& y)
> { return y > x; }
> friend bool operator<=(const U& x, const T& y)
> { return static_cast<bool>(y > x) || static_cast<bool>(y == x); }
> friend bool operator>=(const U& x, const T& y)
> { return static_cast<bool>(y < x) || static_cast<bool>(y == x); }
>};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct partially_ordered1 : B
>{
> friend bool operator>(const T& x, const T& y)
> { return y < x; }
> friend bool operator<=(const T& x, const T& y)
> { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
> friend bool operator>=(const T& x, const T& y)
> { return static_cast<bool>(y < x) || static_cast<bool>(x == y); }
>};
>
>
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct totally_ordered2
> : less_than_comparable2<T, U
> , equality_comparable2<T, U, B
> > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct totally_ordered1
> : less_than_comparable1<T
> , equality_comparable1<T, B
> > > {};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct additive2
> : addable2<T, U
> , subtractable2<T, U, B
> > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct additive1
> : addable1<T
> , subtractable1<T, B
> > > {};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct multiplicative2
> : multipliable2<T, U
> , dividable2<T, U, B
> > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct multiplicative1
> : multipliable1<T
> , dividable1<T, B
> > > {};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct integer_multiplicative2
> : multiplicative2<T, U
> , modable2<T, U, B
> > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct integer_multiplicative1
> : multiplicative1<T
> , modable1<T, B
> > > {};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct arithmetic2
> : additive2<T, U
> , multiplicative2<T, U, B
> > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct arithmetic1
> : additive1<T
> , multiplicative1<T, B
> > > {};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct integer_arithmetic2
> : additive2<T, U
> , integer_multiplicative2<T, U, B
> > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct integer_arithmetic1
> : additive1<T
> , integer_multiplicative1<T, B
> > > {};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct bitwise2
> : xorable2<T, U
> , andable2<T, U
> , orable2<T, U, B
> > > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct bitwise1
> : xorable1<T
> , andable1<T
> , orable1<T, B
> > > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct unit_steppable
> : incrementable<T
> , decrementable<T, B
> > > {};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct shiftable2
> : left_shiftable2<T, U
> , right_shiftable2<T, U, B
> > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct shiftable1
> : left_shiftable1<T
> , right_shiftable1<T, B
> > > {};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct ring_operators2
> : additive2<T, U
> , subtractable2_left<T, U
> , multipliable2<T, U, B
> > > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct ring_operators1
> : additive1<T
> , multipliable1<T, B
> > > {};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct ordered_ring_operators2
> : ring_operators2<T, U
> , totally_ordered2<T, U, B
> > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct ordered_ring_operators1
> : ring_operators1<T
> , totally_ordered1<T, B
> > > {};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct field_operators2
> : ring_operators2<T, U
> , dividable2<T, U
> , dividable2_left<T, U, B
> > > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct field_operators1
> : ring_operators1<T
> , dividable1<T, B
> > > {};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct ordered_field_operators2
> : field_operators2<T, U
> , totally_ordered2<T, U, B
> > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct ordered_field_operators1
> : field_operators1<T
> , totally_ordered1<T, B
> > > {};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct euclidian_ring_operators2
> : ring_operators2<T, U
> , dividable2<T, U
> , dividable2_left<T, U
> , modable2<T, U
> , modable2_left<T, U, B
> > > > > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct euclidian_ring_operators1
> : ring_operators1<T
> , dividable1<T
> , modable1<T, B
> > > > {};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct ordered_euclidian_ring_operators2
> : totally_ordered2<T, U
> , euclidian_ring_operators2<T, U, B
> > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct ordered_euclidian_ring_operators1
> : totally_ordered1<T
> , euclidian_ring_operators1<T, B
> > > {};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct euclidean_ring_operators2
> : ring_operators2<T, U
> , dividable2<T, U
> , dividable2_left<T, U
> , modable2<T, U
> , modable2_left<T, U, B
> > > > > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct euclidean_ring_operators1
> : ring_operators1<T
> , dividable1<T
> , modable1<T, B
> > > > {};
>
>template <class T, class U, class B = ::boost::detail::empty_base<T> >
>struct ordered_euclidean_ring_operators2
> : totally_ordered2<T, U
> , euclidean_ring_operators2<T, U, B
> > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct ordered_euclidean_ring_operators1
> : totally_ordered1<T
> , euclidean_ring_operators1<T, B
> > > {};
>
>template <class T, class P, class B = ::boost::detail::empty_base<T> >
>struct input_iteratable
> : equality_comparable1<T
> , incrementable<T
> , dereferenceable<T, P, B
> > > > {};
>
>template <class T, class B = ::boost::detail::empty_base<T> >
>struct output_iteratable
> : incrementable<T, B
> > {};
>
>template <class T, class P, class B = ::boost::detail::empty_base<T> >
>struct forward_iteratable
> : input_iteratable<T, P, B
> > {};
>
>template <class T, class P, class B = ::boost::detail::empty_base<T> >
>struct bidirectional_iteratable
> : forward_iteratable<T, P
> , decrementable<T, B
> > > {};
>
>
>
>
>
>template <class T, class P, class D, class R, class B = ::boost::detail::empty_base<T> >
>struct random_access_iteratable
> : bidirectional_iteratable<T, P
> , less_than_comparable1<T
> , additive2<T, D
> , indexable<T, D, R, B
> > > > > {};
>
>
>}
># 720 "/usr/include/boost/operators.hpp" 3 4
>namespace boost {
>
>
>namespace detail {
> struct true_t {};
> struct false_t {};
>}
>
>
>
>
>template<class T> struct is_chained_base {
> typedef ::boost::detail::false_t value;
>};
>
>}
># 831 "/usr/include/boost/operators.hpp" 3 4
>namespace boost {
>
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct less_than_comparable : less_than_comparable2<T, U, B> {}; template<class T, class U, class B> struct less_than_comparable<T, U, B, ::boost::detail::true_t> : less_than_comparable1<T, U> {}; template <class T, class B> struct less_than_comparable<T, T, B, ::boost::detail::false_t> : less_than_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::less_than_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::less_than_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::less_than_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct equality_comparable : equality_comparable2<T, U, B> {}; template<class T, class U, class B> struct equality_comparable<T, U, B, ::boost::detail::true_t> : equality_comparable1<T, U> {}; template <class T, class B> struct equality_comparable<T, T, B, ::boost::detail::false_t> : equality_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equality_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::equality_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::equality_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct multipliable : multipliable2<T, U, B> {}; template<class T, class U, class B> struct multipliable<T, U, B, ::boost::detail::true_t> : multipliable1<T, U> {}; template <class T, class B> struct multipliable<T, T, B, ::boost::detail::false_t> : multipliable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multipliable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::multipliable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::multipliable1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct addable : addable2<T, U, B> {}; template<class T, class U, class B> struct addable<T, U, B, ::boost::detail::true_t> : addable1<T, U> {}; template <class T, class B> struct addable<T, T, B, ::boost::detail::false_t> : addable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::addable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::addable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::addable1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct subtractable : subtractable2<T, U, B> {}; template<class T, class U, class B> struct subtractable<T, U, B, ::boost::detail::true_t> : subtractable1<T, U> {}; template <class T, class B> struct subtractable<T, T, B, ::boost::detail::false_t> : subtractable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::subtractable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::subtractable1<T, B> > { typedef ::boost::detail::true_t value; };
> template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct dividable : dividable2<T, U, B> {}; template<class T, class U, class B> struct dividable<T, U, B, ::boost::detail::true_t> : dividable1<T, U> {}; template <class T, class B> struct dividable<T, T, B, ::boost::detail::false_t> : dividable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::dividable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::dividable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::dividable1<T, B> > { typedef ::boost::detail::true_t value; };
> template<class T, class U, class B> struct is_chained_base< ::boost::dividable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct modable : modable2<T, U, B> {}; template<class T, class U, class B> struct modable<T, U, B, ::boost::detail::true_t> : modable1<T, U> {}; template <class T, class B> struct modable<T, T, B, ::boost::detail::false_t> : modable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::modable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::modable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::modable1<T, B> > { typedef ::boost::detail::true_t value; };
> template<class T, class U, class B> struct is_chained_base< ::boost::modable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct xorable : xorable2<T, U, B> {}; template<class T, class U, class B> struct xorable<T, U, B, ::boost::detail::true_t> : xorable1<T, U> {}; template <class T, class B> struct xorable<T, T, B, ::boost::detail::false_t> : xorable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::xorable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::xorable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::xorable1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct andable : andable2<T, U, B> {}; template<class T, class U, class B> struct andable<T, U, B, ::boost::detail::true_t> : andable1<T, U> {}; template <class T, class B> struct andable<T, T, B, ::boost::detail::false_t> : andable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::andable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::andable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::andable1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct orable : orable2<T, U, B> {}; template<class T, class U, class B> struct orable<T, U, B, ::boost::detail::true_t> : orable1<T, U> {}; template <class T, class B> struct orable<T, T, B, ::boost::detail::false_t> : orable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::orable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::orable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::orable1<T, B> > { typedef ::boost::detail::true_t value; };
>
> template<class T, class B> struct is_chained_base< ::boost::incrementable<T, B> > { typedef ::boost::detail::true_t value; };
> template<class T, class B> struct is_chained_base< ::boost::decrementable<T, B> > { typedef ::boost::detail::true_t value; };
>
> template<class T, class U, class B> struct is_chained_base< ::boost::dereferenceable<T, U, B> > { typedef ::boost::detail::true_t value; };
> template<class T, class U, class V, class B> struct is_chained_base< ::boost::indexable<T, U, V, B> > { typedef ::boost::detail::true_t value; };
>
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct left_shiftable : left_shiftable2<T, U, B> {}; template<class T, class U, class B> struct left_shiftable<T, U, B, ::boost::detail::true_t> : left_shiftable1<T, U> {}; template <class T, class B> struct left_shiftable<T, T, B, ::boost::detail::false_t> : left_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::left_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::left_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::left_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct right_shiftable : right_shiftable2<T, U, B> {}; template<class T, class U, class B> struct right_shiftable<T, U, B, ::boost::detail::true_t> : right_shiftable1<T, U> {}; template <class T, class B> struct right_shiftable<T, T, B, ::boost::detail::false_t> : right_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::right_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::right_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::right_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct equivalent : equivalent2<T, U, B> {}; template<class T, class U, class B> struct equivalent<T, U, B, ::boost::detail::true_t> : equivalent1<T, U> {}; template <class T, class B> struct equivalent<T, T, B, ::boost::detail::false_t> : equivalent1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equivalent<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::equivalent2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::equivalent1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct partially_ordered : partially_ordered2<T, U, B> {}; template<class T, class U, class B> struct partially_ordered<T, U, B, ::boost::detail::true_t> : partially_ordered1<T, U> {}; template <class T, class B> struct partially_ordered<T, T, B, ::boost::detail::false_t> : partially_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::partially_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::partially_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::partially_ordered1<T, B> > { typedef ::boost::detail::true_t value; };
>
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct totally_ordered : totally_ordered2<T, U, B> {}; template<class T, class U, class B> struct totally_ordered<T, U, B, ::boost::detail::true_t> : totally_ordered1<T, U> {}; template <class T, class B> struct totally_ordered<T, T, B, ::boost::detail::false_t> : totally_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::totally_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::totally_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::totally_ordered1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct additive : additive2<T, U, B> {}; template<class T, class U, class B> struct additive<T, U, B, ::boost::detail::true_t> : additive1<T, U> {}; template <class T, class B> struct additive<T, T, B, ::boost::detail::false_t> : additive1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::additive<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::additive2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::additive1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct multiplicative : multiplicative2<T, U, B> {}; template<class T, class U, class B> struct multiplicative<T, U, B, ::boost::detail::true_t> : multiplicative1<T, U> {}; template <class T, class B> struct multiplicative<T, T, B, ::boost::detail::false_t> : multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct integer_multiplicative : integer_multiplicative2<T, U, B> {}; template<class T, class U, class B> struct integer_multiplicative<T, U, B, ::boost::detail::true_t> : integer_multiplicative1<T, U> {}; template <class T, class B> struct integer_multiplicative<T, T, B, ::boost::detail::false_t> : integer_multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::integer_multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::integer_multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct arithmetic : arithmetic2<T, U, B> {}; template<class T, class U, class B> struct arithmetic<T, U, B, ::boost::detail::true_t> : arithmetic1<T, U> {}; template <class T, class B> struct arithmetic<T, T, B, ::boost::detail::false_t> : arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct integer_arithmetic : integer_arithmetic2<T, U, B> {}; template<class T, class U, class B> struct integer_arithmetic<T, U, B, ::boost::detail::true_t> : integer_arithmetic1<T, U> {}; template <class T, class B> struct integer_arithmetic<T, T, B, ::boost::detail::false_t> : integer_arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::integer_arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::integer_arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct bitwise : bitwise2<T, U, B> {}; template<class T, class U, class B> struct bitwise<T, U, B, ::boost::detail::true_t> : bitwise1<T, U> {}; template <class T, class B> struct bitwise<T, T, B, ::boost::detail::false_t> : bitwise1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::bitwise<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::bitwise2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::bitwise1<T, B> > { typedef ::boost::detail::true_t value; };
> template<class T, class B> struct is_chained_base< ::boost::unit_steppable<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct shiftable : shiftable2<T, U, B> {}; template<class T, class U, class B> struct shiftable<T, U, B, ::boost::detail::true_t> : shiftable1<T, U> {}; template <class T, class B> struct shiftable<T, T, B, ::boost::detail::false_t> : shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct ring_operators : ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ring_operators<T, U, B, ::boost::detail::true_t> : ring_operators1<T, U> {}; template <class T, class B> struct ring_operators<T, T, B, ::boost::detail::false_t> : ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct ordered_ring_operators : ordered_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_ring_operators1<T, U> {}; template <class T, class B> struct ordered_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct field_operators : field_operators2<T, U, B> {}; template<class T, class U, class B> struct field_operators<T, U, B, ::boost::detail::true_t> : field_operators1<T, U> {}; template <class T, class B> struct field_operators<T, T, B, ::boost::detail::false_t> : field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct ordered_field_operators : ordered_field_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_field_operators<T, U, B, ::boost::detail::true_t> : ordered_field_operators1<T, U> {}; template <class T, class B> struct ordered_field_operators<T, T, B, ::boost::detail::false_t> : ordered_field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct euclidian_ring_operators : euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : euclidian_ring_operators1<T, U> {}; template <class T, class B> struct euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct ordered_euclidian_ring_operators : ordered_euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_euclidian_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct euclidean_ring_operators : euclidean_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct euclidean_ring_operators<T, U, B, ::boost::detail::true_t> : euclidean_ring_operators1<T, U> {}; template <class T, class B> struct euclidean_ring_operators<T, T, B, ::boost::detail::false_t> : euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::euclidean_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::euclidean_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::euclidean_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
>template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base::value > struct ordered_euclidean_ring_operators : ordered_euclidean_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_euclidean_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_euclidean_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidean_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_euclidean_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_euclidean_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_euclidean_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
> template<class T, class U, class B> struct is_chained_base< ::boost::input_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
> template<class T, class B> struct is_chained_base< ::boost::output_iteratable<T, B> > { typedef ::boost::detail::true_t value; };
> template<class T, class U, class B> struct is_chained_base< ::boost::forward_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
> template<class T, class U, class B> struct is_chained_base< ::boost::bidirectional_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
> template<class T, class U, class V, class W, class B> struct is_chained_base< ::boost::random_access_iteratable<T, U, V, W, B> > { typedef ::boost::detail::true_t value; };
># 893 "/usr/include/boost/operators.hpp" 3 4
>template <class T, class U>
>struct operators2
> : totally_ordered2<T,U
> , integer_arithmetic2<T,U
> , bitwise2<T,U
> > > > {};
>
>
>template <class T, class U = T>
>struct operators : operators2<T, U> {};
>
>template <class T> struct operators<T, T>
>
>
>
> : totally_ordered<T
> , integer_arithmetic<T
> , bitwise<T
> , unit_steppable<T
> > > > > {};
>
>
>
>
>template <class T,
> class V,
> class D = std::ptrdiff_t,
> class P = V const *,
> class R = V const &>
>struct input_iterator_helper
> : input_iteratable<T, P
> , boost::iterator<std::input_iterator_tag, V, D, P, R
> > > {};
>
>template<class T>
>struct output_iterator_helper
> : output_iteratable<T
> , boost::iterator<std::output_iterator_tag, void, void, void, void
> > >
>{
> T& operator*() { return static_cast<T&>(*this); }
> T& operator++() { return static_cast<T&>(*this); }
>};
>
>template <class T,
> class V,
> class D = std::ptrdiff_t,
> class P = V*,
> class R = V&>
>struct forward_iterator_helper
> : forward_iteratable<T, P
> , boost::iterator<std::forward_iterator_tag, V, D, P, R
> > > {};
>
>template <class T,
> class V,
> class D = std::ptrdiff_t,
> class P = V*,
> class R = V&>
>struct bidirectional_iterator_helper
> : bidirectional_iteratable<T, P
> , boost::iterator<std::bidirectional_iterator_tag, V, D, P, R
> > > {};
>
>template <class T,
> class V,
> class D = std::ptrdiff_t,
> class P = V*,
> class R = V&>
>struct random_access_iterator_helper
> : random_access_iteratable<T, P, D, R
> , boost::iterator<std::random_access_iterator_tag, V, D, P, R
> > >
>{
> friend D requires_difference_operator(const T& x, const T& y) {
> return x - y;
> }
>};
>
>}
># 18 "/usr/include/boost/system/error_code.hpp" 2 3 4
># 1 "/usr/include/boost/noncopyable.hpp" 1 3 4
># 14 "/usr/include/boost/noncopyable.hpp" 3 4
>namespace boost {
>
>
>
>
>
>
>namespace noncopyable_
>{
> class noncopyable
> {
> protected:
>
> constexpr noncopyable() = default;
> ~noncopyable() = default;
>
>
>
>
>
> noncopyable( const noncopyable& ) = delete;
> noncopyable& operator=( const noncopyable& ) = delete;
>
>
>
>
>
> };
>}
>
>typedef noncopyable_::noncopyable noncopyable;
>
>}
># 19 "/usr/include/boost/system/error_code.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/cerrno.hpp" 1 3 4
># 13 "/usr/include/boost/cerrno.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cerrno" 1 3 4
># 39 "/usr/include/c++/4.8.2/cerrno" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cerrno" 3
>
># 1 "/usr/include/errno.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cerrno" 2 3
># 14 "/usr/include/boost/cerrno.hpp" 2 3 4
># 27 "/usr/include/boost/system/error_code.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 33 "/usr/include/boost/system/error_code.hpp" 2 3 4
>
>
>
>
>
>namespace boost
>{
> namespace system
> {
>
> class error_code;
> class error_condition;
>
>
>
> template< class T >
> struct is_error_code_enum { static const bool value = false; };
>
> template< class T >
> struct is_error_condition_enum { static const bool value = false; };
>
>
>
> namespace errc
> {
> enum errc_t
> {
> success = 0,
> address_family_not_supported = 97,
> address_in_use = 98,
> address_not_available = 99,
> already_connected = 106,
> argument_list_too_long = 7,
> argument_out_of_domain = 33,
> bad_address = 14,
> bad_file_descriptor = 9,
> bad_message = 74,
> broken_pipe = 32,
> connection_aborted = 103,
> connection_already_in_progress = 114,
> connection_refused = 111,
> connection_reset = 104,
> cross_device_link = 18,
> destination_address_required = 89,
> device_or_resource_busy = 16,
> directory_not_empty = 39,
> executable_format_error = 8,
> file_exists = 17,
> file_too_large = 27,
> filename_too_long = 36,
> function_not_supported = 38,
> host_unreachable = 113,
> identifier_removed = 43,
> illegal_byte_sequence = 84,
> inappropriate_io_control_operation = 25,
> interrupted = 4,
> invalid_argument = 22,
> invalid_seek = 29,
> io_error = 5,
> is_a_directory = 21,
> message_size = 90,
> network_down = 100,
> network_reset = 102,
> network_unreachable = 101,
> no_buffer_space = 105,
> no_child_process = 10,
> no_link = 67,
> no_lock_available = 37,
> no_message_available = 61,
> no_message = 42,
> no_protocol_option = 92,
> no_space_on_device = 28,
> no_stream_resources = 63,
> no_such_device_or_address = 6,
> no_such_device = 19,
> no_such_file_or_directory = 2,
> no_such_process = 3,
> not_a_directory = 20,
> not_a_socket = 88,
> not_a_stream = 60,
> not_connected = 107,
> not_enough_memory = 12,
> not_supported = 95,
> operation_canceled = 125,
> operation_in_progress = 115,
> operation_not_permitted = 1,
> operation_not_supported = 95,
> operation_would_block = 11,
> owner_dead = 130,
> permission_denied = 13,
> protocol_error = 71,
> protocol_not_supported = 93,
> read_only_file_system = 30,
> resource_deadlock_would_occur = 35,
> resource_unavailable_try_again = 11,
> result_out_of_range = 34,
> state_not_recoverable = 131,
> stream_timeout = 62,
> text_file_busy = 26,
> timed_out = 110,
> too_many_files_open_in_system = 23,
> too_many_files_open = 24,
> too_many_links = 31,
> too_many_symbolic_link_levels = 40,
> value_too_large = 75,
> wrong_protocol_type = 91
> };
>
> }
>
>
> namespace posix = errc;
> namespace posix_error = errc;
>
>
> template<> struct is_error_condition_enum<errc::errc_t>
> { static const bool value = true; };
># 186 "/usr/include/boost/system/error_code.hpp" 3 4
> class error_category : public noncopyable
> {
> public:
> virtual ~error_category(){}
>
> virtual const char * name() const noexcept = 0;
> virtual std::string message( int ev ) const = 0;
> inline virtual error_condition default_error_condition( int ev ) const noexcept;
> inline virtual bool equivalent( int code,
> const error_condition & condition ) const noexcept;
> inline virtual bool equivalent( const error_code & code,
> int condition ) const noexcept;
>
> bool operator==(const error_category & rhs) const noexcept { return this == &rhs; }
> bool operator!=(const error_category & rhs) const noexcept { return this != &rhs; }
> bool operator<( const error_category & rhs ) const noexcept
> {
> return std::less<const error_category*>()( this, &rhs );
> }
> };
>
>
>
>
>
>
>
> const error_category & system_category() noexcept;
> const error_category & generic_category() noexcept;
>
>
>
>
> inline const error_category & get_system_category() { return system_category(); }
> inline const error_category & get_generic_category() { return generic_category(); }
> inline const error_category & get_posix_category() { return generic_category(); }
> static const error_category & posix_category = generic_category();
> static const error_category & errno_ecat = generic_category();
> static const error_category & native_ecat = system_category();
>
>
>
>
>
>
> class error_condition
> {
> public:
>
>
> error_condition() noexcept : m_val(0), m_cat(&generic_category()) {}
> error_condition( int val, const error_category & cat ) noexcept : m_val(val), m_cat(&cat) {}
>
> template <class ErrorConditionEnum>
> error_condition(ErrorConditionEnum e,
> typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum> >::type* = 0) noexcept
> {
> *this = make_error_condition(e);
> }
>
>
>
> void assign( int val, const error_category & cat ) noexcept
> {
> m_val = val;
> m_cat = &cat;
> }
>
> template<typename ErrorConditionEnum>
> typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum>, error_condition>::type &
> operator=( ErrorConditionEnum val ) noexcept
> {
> *this = make_error_condition(val);
> return *this;
> }
>
> void clear() noexcept
> {
> m_val = 0;
> m_cat = &generic_category();
> }
>
>
> int value() const noexcept { return m_val; }
> const error_category & category() const noexcept { return *m_cat; }
> std::string message() const { return m_cat->message(value()); }
>
> typedef void (*unspecified_bool_type)();
> static void unspecified_bool_true() {}
>
> operator unspecified_bool_type() const noexcept
> {
> return m_val == 0 ? 0 : unspecified_bool_true;
> }
>
> bool operator!() const noexcept
> {
> return m_val == 0;
> }
>
>
>
>
> inline friend bool operator==( const error_condition & lhs,
> const error_condition & rhs ) noexcept
> {
> return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
> }
>
> inline friend bool operator<( const error_condition & lhs,
> const error_condition & rhs ) noexcept
>
>
> {
> return lhs.m_cat < rhs.m_cat
> || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
> }
>
> private:
> int m_val;
> const error_category * m_cat;
>
> };
># 318 "/usr/include/boost/system/error_code.hpp" 3 4
> class error_code
> {
> public:
>
>
> error_code() noexcept : m_val(0), m_cat(&system_category()) {}
> error_code( int val, const error_category & cat ) noexcept : m_val(val), m_cat(&cat) {}
>
> template <class ErrorCodeEnum>
> error_code(ErrorCodeEnum e,
> typename boost::enable_if<is_error_code_enum<ErrorCodeEnum> >::type* = 0) noexcept
> {
> *this = make_error_code(e);
> }
>
>
> void assign( int val, const error_category & cat ) noexcept
> {
> m_val = val;
> m_cat = &cat;
> }
>
> template<typename ErrorCodeEnum>
> typename boost::enable_if<is_error_code_enum<ErrorCodeEnum>, error_code>::type &
> operator=( ErrorCodeEnum val ) noexcept
> {
> *this = make_error_code(val);
> return *this;
> }
>
> void clear() noexcept
> {
> m_val = 0;
> m_cat = &system_category();
> }
>
>
> int value() const noexcept { return m_val; }
> const error_category & category() const noexcept { return *m_cat; }
> error_condition default_error_condition() const noexcept { return m_cat->default_error_condition(value()); }
> std::string message() const { return m_cat->message(value()); }
>
> typedef void (*unspecified_bool_type)();
> static void unspecified_bool_true() {}
>
> operator unspecified_bool_type() const noexcept
> {
> return m_val == 0 ? 0 : unspecified_bool_true;
> }
>
> bool operator!() const noexcept
> {
> return m_val == 0;
> }
>
>
> inline friend bool operator==( const error_code & lhs,
> const error_code & rhs ) noexcept
>
>
> {
> return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
> }
>
> inline friend bool operator<( const error_code & lhs,
> const error_code & rhs ) noexcept
>
>
> {
> return lhs.m_cat < rhs.m_cat
> || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
> }
>
> private:
> int m_val;
> const error_category * m_cat;
>
> };
>
>
>
> extern error_code throws;
>
>
>
>
>
>
> }
>
> namespace detail { inline system::error_code * throws() { return 0; } }
># 417 "/usr/include/boost/system/error_code.hpp" 3 4
> inline system::error_code & throws()
> { return *detail::throws(); }
>
> namespace system
> {
>
>
> inline bool operator!=( const error_code & lhs,
> const error_code & rhs ) noexcept
> {
> return !(lhs == rhs);
> }
>
> inline bool operator!=( const error_condition & lhs,
> const error_condition & rhs ) noexcept
> {
> return !(lhs == rhs);
> }
>
> inline bool operator==( const error_code & code,
> const error_condition & condition ) noexcept
> {
> return code.category().equivalent( code.value(), condition )
> || condition.category().equivalent( code, condition.value() );
> }
>
> inline bool operator!=( const error_code & lhs,
> const error_condition & rhs ) noexcept
> {
> return !(lhs == rhs);
> }
>
> inline bool operator==( const error_condition & condition,
> const error_code & code ) noexcept
> {
> return condition.category().equivalent( code, condition.value() )
> || code.category().equivalent( code.value(), condition );
> }
>
> inline bool operator!=( const error_condition & lhs,
> const error_code & rhs ) noexcept
> {
> return !(lhs == rhs);
> }
>
>
>
> template <class charT, class traits>
> inline std::basic_ostream<charT,traits>&
> operator<< (std::basic_ostream<charT,traits>& os, error_code ec)
> {
> os << ec.category().name() << ':' << ec.value();
> return os;
> }
>
> inline std::size_t hash_value( const error_code & ec )
> {
> return static_cast<std::size_t>(ec.value())
> + reinterpret_cast<std::size_t>(&ec.category());
> }
>
>
>
> namespace errc
> {
>
> inline error_code make_error_code( errc_t e ) noexcept
> { return error_code( e, generic_category() ); }
>
>
> inline error_condition make_error_condition( errc_t e ) noexcept
> { return error_condition( e, generic_category() ); }
> }
>
>
>
> error_condition error_category::default_error_condition( int ev ) const noexcept
> {
> return error_condition( ev, *this );
> }
>
> bool error_category::equivalent( int code,
> const error_condition & condition ) const noexcept
> {
> return default_error_condition( code ) == condition;
> }
>
> bool error_category::equivalent( const error_code & code,
> int condition ) const noexcept
> {
> return *this == code.category() && code.value() == condition;
> }
>
> }
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 514 "/usr/include/boost/system/error_code.hpp" 2 3 4
># 20 "/usr/include/boost/asio/detail/throw_error.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/throw_error.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>inline void do_throw_error(const boost::system::error_code& err);
>
>inline void do_throw_error(const boost::system::error_code& err,
> const char* location);
>
>inline void throw_error(const boost::system::error_code& err)
>{
> if (err)
> do_throw_error(err);
>}
>
>inline void throw_error(const boost::system::error_code& err,
> const char* location)
>{
> if (err)
> do_throw_error(err, location);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 50 "/usr/include/boost/asio/detail/throw_error.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/throw_error.ipp" 1 3 4
># 19 "/usr/include/boost/asio/detail/impl/throw_error.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/throw_error.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/throw_error.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/throw_exception.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/throw_exception.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>using boost::throw_exception;
># 49 "/usr/include/boost/asio/detail/throw_exception.hpp" 3 4
>}
>}
>}
># 21 "/usr/include/boost/asio/detail/impl/throw_error.ipp" 2 3 4
># 1 "/usr/include/boost/system/system_error.hpp" 1 3 4
># 13 "/usr/include/boost/system/system_error.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cassert" 1 3 4
># 41 "/usr/include/c++/4.8.2/cassert" 3 4
> 
># 42 "/usr/include/c++/4.8.2/cassert" 3
>
># 1 "/usr/include/assert.h" 1 3 4
># 64 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (const char *__assertion, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 43 "/usr/include/c++/4.8.2/cassert" 2 3
># 14 "/usr/include/boost/system/system_error.hpp" 2 3 4
>
>
>namespace boost
>{
> namespace system
> {
>
>
> class __attribute__((__visibility__("default"))) system_error : public std::runtime_error
>
>
> {
> public:
> system_error( error_code ec )
> : std::runtime_error(""), m_error_code(ec) {}
>
> system_error( error_code ec, const std::string & what_arg )
> : std::runtime_error(what_arg), m_error_code(ec) {}
>
> system_error( error_code ec, const char* what_arg )
> : std::runtime_error(what_arg), m_error_code(ec) {}
>
> system_error( int ev, const error_category & ecat )
> : std::runtime_error(""), m_error_code(ev,ecat) {}
>
> system_error( int ev, const error_category & ecat,
> const std::string & what_arg )
> : std::runtime_error(what_arg), m_error_code(ev,ecat) {}
>
> system_error( int ev, const error_category & ecat,
> const char * what_arg )
> : std::runtime_error(what_arg), m_error_code(ev,ecat) {}
>
> virtual ~system_error() throw() {}
>
> const error_code & code() const throw() { return m_error_code; }
> const char * what() const throw();
>
> private:
> error_code m_error_code;
> mutable std::string m_what;
> };
>
>
>
> inline const char * system_error::what() const throw()
>
> {
> if ( m_what.empty() )
> {
>
> try
>
> {
> m_what = this->std::runtime_error::what();
> if ( !m_what.empty() ) m_what += ": ";
> m_what += m_error_code.message();
> }
>
> catch (...) { return std::runtime_error::what(); }
>
> }
> return m_what.c_str();
> }
>
> }
>}
># 22 "/usr/include/boost/asio/detail/impl/throw_error.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/impl/throw_error.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>void do_throw_error(const boost::system::error_code& err)
>{
> boost::system::system_error e(err);
> boost::asio::detail::throw_exception(e);
>}
>
>void do_throw_error(const boost::system::error_code& err, const char* location)
>{
> boost::system::system_error e(err, location);
> boost::asio::detail::throw_exception(e);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 46 "/usr/include/boost/asio/detail/impl/throw_error.ipp" 2 3 4
># 53 "/usr/include/boost/asio/detail/throw_error.hpp" 2 3 4
># 24 "/usr/include/boost/asio/detail/impl/posix_event.ipp" 2 3 4
># 1 "/usr/include/boost/asio/error.hpp" 1 3 4
># 24 "/usr/include/boost/asio/error.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cerrno" 1 3 4
># 39 "/usr/include/c++/4.8.2/cerrno" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cerrno" 3
>
># 1 "/usr/include/errno.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cerrno" 2 3
># 25 "/usr/include/boost/asio/error.hpp" 2 3 4
># 1 "/usr/include/netdb.h" 1 3 4
># 27 "/usr/include/netdb.h" 3 4
># 1 "/usr/include/netinet/in.h" 1 3 4
># 23 "/usr/include/netinet/in.h" 3 4
># 1 "/usr/include/sys/socket.h" 1 3 4
># 24 "/usr/include/sys/socket.h" 3 4
>extern "C" {
>
># 1 "/usr/include/sys/uio.h" 1 3 4
># 25 "/usr/include/sys/uio.h" 3 4
>extern "C" {
>
>
># 1 "/usr/include/bits/uio.h" 1 3 4
># 43 "/usr/include/bits/uio.h" 3 4
>struct iovec
> {
> void *iov_base;
> size_t iov_len;
> };
># 56 "/usr/include/bits/uio.h" 3 4
>extern "C" {
>
>
>extern ssize_t process_vm_readv (pid_t __pid, const struct iovec *__lvec,
> unsigned long int __liovcnt,
> const struct iovec *__rvec,
> unsigned long int __riovcnt,
> unsigned long int __flags)
> throw ();
>
>
>extern ssize_t process_vm_writev (pid_t __pid, const struct iovec *__lvec,
> unsigned long int __liovcnt,
> const struct iovec *__rvec,
> unsigned long int __riovcnt,
> unsigned long int __flags)
> throw ();
>
>}
># 29 "/usr/include/sys/uio.h" 2 3 4
># 39 "/usr/include/sys/uio.h" 3 4
>extern ssize_t readv (int __fd, const struct iovec *__iovec, int __count)
> ;
># 50 "/usr/include/sys/uio.h" 3 4
>extern ssize_t writev (int __fd, const struct iovec *__iovec, int __count)
> ;
># 65 "/usr/include/sys/uio.h" 3 4
>extern ssize_t preadv (int __fd, const struct iovec *__iovec, int __count,
> __off_t __offset) ;
># 77 "/usr/include/sys/uio.h" 3 4
>extern ssize_t pwritev (int __fd, const struct iovec *__iovec, int __count,
> __off_t __offset) ;
># 103 "/usr/include/sys/uio.h" 3 4
>extern ssize_t preadv64 (int __fd, const struct iovec *__iovec, int __count,
> __off64_t __offset) ;
># 115 "/usr/include/sys/uio.h" 3 4
>extern ssize_t pwritev64 (int __fd, const struct iovec *__iovec, int __count,
> __off64_t __offset) ;
>
>
>
>}
># 27 "/usr/include/sys/socket.h" 2 3 4
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 29 "/usr/include/sys/socket.h" 2 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 32 "/usr/include/sys/socket.h" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/bits/socket.h" 1 3 4
># 27 "/usr/include/bits/socket.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 28 "/usr/include/bits/socket.h" 2 3 4
># 38 "/usr/include/bits/socket.h" 3 4
># 1 "/usr/include/bits/socket_type.h" 1 3 4
># 24 "/usr/include/bits/socket_type.h" 3 4
>enum __socket_type
>{
> SOCK_STREAM = 1,
>
>
> SOCK_DGRAM = 2,
>
>
> SOCK_RAW = 3,
>
> SOCK_RDM = 4,
>
> SOCK_SEQPACKET = 5,
>
>
> SOCK_DCCP = 6,
>
> SOCK_PACKET = 10,
>
>
>
>
>
>
>
> SOCK_CLOEXEC = 02000000,
>
>
> SOCK_NONBLOCK = 00004000
>
>
>};
># 39 "/usr/include/bits/socket.h" 2 3 4
># 146 "/usr/include/bits/socket.h" 3 4
># 1 "/usr/include/bits/sockaddr.h" 1 3 4
># 28 "/usr/include/bits/sockaddr.h" 3 4
>typedef unsigned short int sa_family_t;
># 147 "/usr/include/bits/socket.h" 2 3 4
>
>
>struct sockaddr
> {
> sa_family_t sa_family;
> char sa_data[14];
> };
># 162 "/usr/include/bits/socket.h" 3 4
>struct sockaddr_storage
> {
> sa_family_t ss_family;
> unsigned long int __ss_align;
> char __ss_padding[(128 - (2 * sizeof (unsigned long int)))];
> };
>
>
>
>enum
> {
> MSG_OOB = 0x01,
>
> MSG_PEEK = 0x02,
>
> MSG_DONTROUTE = 0x04,
>
>
>
> MSG_TRYHARD = MSG_DONTROUTE,
>
>
> MSG_CTRUNC = 0x08,
>
> MSG_PROXY = 0x10,
>
> MSG_TRUNC = 0x20,
>
> MSG_DONTWAIT = 0x40,
>
> MSG_EOR = 0x80,
>
> MSG_WAITALL = 0x100,
>
> MSG_FIN = 0x200,
>
> MSG_SYN = 0x400,
>
> MSG_CONFIRM = 0x800,
>
> MSG_RST = 0x1000,
>
> MSG_ERRQUEUE = 0x2000,
>
> MSG_NOSIGNAL = 0x4000,
>
> MSG_MORE = 0x8000,
>
> MSG_WAITFORONE = 0x10000,
>
> MSG_FASTOPEN = 0x20000000,
>
>
> MSG_CMSG_CLOEXEC = 0x40000000
>
>
>
> };
>
>
>
>
>struct msghdr
> {
> void *msg_name;
> socklen_t msg_namelen;
>
> struct iovec *msg_iov;
> size_t msg_iovlen;
>
> void *msg_control;
> size_t msg_controllen;
>
>
>
>
> int msg_flags;
> };
>
>
>struct cmsghdr
> {
> size_t cmsg_len;
>
>
>
>
> int cmsg_level;
> int cmsg_type;
>
>
>
> };
># 272 "/usr/include/bits/socket.h" 3 4
>extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr,
> struct cmsghdr *__cmsg) throw ();
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) struct cmsghdr *
>__attribute__ ((__leaf__)) __cmsg_nxthdr (struct msghdr *__mhdr, struct cmsghdr *__cmsg) throw ()
>{
> if ((size_t) __cmsg->cmsg_len < sizeof (struct cmsghdr))
>
> return (struct cmsghdr *) 0;
>
> __cmsg = (struct cmsghdr *) ((unsigned char *) __cmsg
> + (((__cmsg->cmsg_len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1)));
> if ((unsigned char *) (__cmsg + 1) > ((unsigned char *) __mhdr->msg_control
> + __mhdr->msg_controllen)
> || ((unsigned char *) __cmsg + (((__cmsg->cmsg_len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1))
> > ((unsigned char *) __mhdr->msg_control + __mhdr->msg_controllen)))
>
> return (struct cmsghdr *) 0;
> return __cmsg;
>}
>
>
>
>
>enum
> {
> SCM_RIGHTS = 0x01
>
>
> , SCM_CREDENTIALS = 0x02
>
>
> };
>
>
>
>struct ucred
>{
> pid_t pid;
> uid_t uid;
> gid_t gid;
>};
># 345 "/usr/include/bits/socket.h" 3 4
># 1 "/usr/include/asm/socket.h" 1 3 4
># 1 "/usr/include/asm-generic/socket.h" 1 3 4
>
>
>
># 1 "/usr/include/asm/sockios.h" 1 3 4
># 1 "/usr/include/asm-generic/sockios.h" 1 3 4
># 1 "/usr/include/asm/sockios.h" 2 3 4
># 5 "/usr/include/asm-generic/socket.h" 2 3 4
># 1 "/usr/include/asm/socket.h" 2 3 4
># 346 "/usr/include/bits/socket.h" 2 3 4
># 379 "/usr/include/bits/socket.h" 3 4
>struct linger
> {
> int l_onoff;
> int l_linger;
> };
># 39 "/usr/include/sys/socket.h" 2 3 4
>
>
>
>
>struct osockaddr
> {
> unsigned short int sa_family;
> unsigned char sa_data[14];
> };
>
>
>
>
>enum
>{
> SHUT_RD = 0,
>
> SHUT_WR,
>
> SHUT_RDWR
>
>};
># 101 "/usr/include/sys/socket.h" 3 4
>struct mmsghdr
> {
> struct msghdr msg_hdr;
> unsigned int msg_len;
>
> };
>
>
>
>
>
>
>extern int socket (int __domain, int __type, int __protocol) throw ();
>
>
>
>
>
>extern int socketpair (int __domain, int __type, int __protocol,
> int __fds[2]) throw ();
>
>
>extern int bind (int __fd, const struct sockaddr * __addr, socklen_t __len)
> throw ();
>
>
>extern int getsockname (int __fd, struct sockaddr *__restrict __addr,
> socklen_t *__restrict __len) throw ();
># 137 "/usr/include/sys/socket.h" 3 4
>extern int connect (int __fd, const struct sockaddr * __addr, socklen_t __len);
>
>
>
>extern int getpeername (int __fd, struct sockaddr *__restrict __addr,
> socklen_t *__restrict __len) throw ();
>
>
>
>
>
>
>extern ssize_t send (int __fd, const void *__buf, size_t __n, int __flags);
>
>
>
>
>
>
>extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);
>
>
>
>
>
>
>extern ssize_t sendto (int __fd, const void *__buf, size_t __n,
> int __flags, const struct sockaddr * __addr,
> socklen_t __addr_len);
># 174 "/usr/include/sys/socket.h" 3 4
>extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
> int __flags, struct sockaddr *__restrict __addr,
> socklen_t *__restrict __addr_len);
>
>
>
>
>
>
>
>extern ssize_t sendmsg (int __fd, const struct msghdr *__message,
> int __flags);
>
>
>
>
>
>
>
>extern int sendmmsg (int __fd, struct mmsghdr *__vmessages,
> unsigned int __vlen, int __flags);
>
>
>
>
>
>
>
>extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);
>
>
>
>
>
>
>
>extern int recvmmsg (int __fd, struct mmsghdr *__vmessages,
> unsigned int __vlen, int __flags,
> const struct timespec *__tmo);
>
>
>
>
>
>
>extern int getsockopt (int __fd, int __level, int __optname,
> void *__restrict __optval,
> socklen_t *__restrict __optlen) throw ();
>
>
>
>
>extern int setsockopt (int __fd, int __level, int __optname,
> const void *__optval, socklen_t __optlen) throw ();
>
>
>
>
>
>extern int listen (int __fd, int __n) throw ();
># 243 "/usr/include/sys/socket.h" 3 4
>extern int accept (int __fd, struct sockaddr *__restrict __addr,
> socklen_t *__restrict __addr_len);
>
>
>
>
>
>
>extern int accept4 (int __fd, struct sockaddr *__restrict __addr,
> socklen_t *__restrict __addr_len, int __flags);
># 261 "/usr/include/sys/socket.h" 3 4
>extern int shutdown (int __fd, int __how) throw ();
>
>
>
>
>extern int sockatmark (int __fd) throw ();
>
>
>
>
>
>
>
>extern int isfdtype (int __fd, int __fdtype) throw ();
># 283 "/usr/include/sys/socket.h" 3 4
>}
># 24 "/usr/include/netinet/in.h" 2 3 4
>
>
>
>extern "C" {
>
>
>enum
> {
> IPPROTO_IP = 0,
>
> IPPROTO_HOPOPTS = 0,
>
> IPPROTO_ICMP = 1,
>
> IPPROTO_IGMP = 2,
>
> IPPROTO_IPIP = 4,
>
> IPPROTO_TCP = 6,
>
> IPPROTO_EGP = 8,
>
> IPPROTO_PUP = 12,
>
> IPPROTO_UDP = 17,
>
> IPPROTO_IDP = 22,
>
> IPPROTO_TP = 29,
>
> IPPROTO_DCCP = 33,
>
> IPPROTO_IPV6 = 41,
>
> IPPROTO_ROUTING = 43,
>
> IPPROTO_FRAGMENT = 44,
>
> IPPROTO_RSVP = 46,
>
> IPPROTO_GRE = 47,
>
> IPPROTO_ESP = 50,
>
> IPPROTO_AH = 51,
>
> IPPROTO_ICMPV6 = 58,
>
> IPPROTO_NONE = 59,
>
> IPPROTO_DSTOPTS = 60,
>
> IPPROTO_MTP = 92,
>
> IPPROTO_ENCAP = 98,
>
> IPPROTO_PIM = 103,
>
> IPPROTO_COMP = 108,
>
> IPPROTO_SCTP = 132,
>
> IPPROTO_UDPLITE = 136,
>
> IPPROTO_RAW = 255,
>
> IPPROTO_MAX
> };
>
>
>
>typedef uint16_t in_port_t;
>
>
>enum
> {
> IPPORT_ECHO = 7,
> IPPORT_DISCARD = 9,
> IPPORT_SYSTAT = 11,
> IPPORT_DAYTIME = 13,
> IPPORT_NETSTAT = 15,
> IPPORT_FTP = 21,
> IPPORT_TELNET = 23,
> IPPORT_SMTP = 25,
> IPPORT_TIMESERVER = 37,
> IPPORT_NAMESERVER = 42,
> IPPORT_WHOIS = 43,
> IPPORT_MTP = 57,
>
> IPPORT_TFTP = 69,
> IPPORT_RJE = 77,
> IPPORT_FINGER = 79,
> IPPORT_TTYLINK = 87,
> IPPORT_SUPDUP = 95,
>
>
> IPPORT_EXECSERVER = 512,
> IPPORT_LOGINSERVER = 513,
> IPPORT_CMDSERVER = 514,
> IPPORT_EFSSERVER = 520,
>
>
> IPPORT_BIFFUDP = 512,
> IPPORT_WHOSERVER = 513,
> IPPORT_ROUTESERVER = 520,
>
>
> IPPORT_RESERVED = 1024,
>
>
> IPPORT_USERRESERVED = 5000
> };
>
>
>
>typedef uint32_t in_addr_t;
>struct in_addr
> {
> in_addr_t s_addr;
> };
># 196 "/usr/include/netinet/in.h" 3 4
>struct in6_addr
> {
> union
> {
> uint8_t __u6_addr8[16];
>
> uint16_t __u6_addr16[8];
> uint32_t __u6_addr32[4];
>
> } __in6_u;
>
>
>
>
>
> };
>
>extern const struct in6_addr in6addr_any;
>extern const struct in6_addr in6addr_loopback;
># 223 "/usr/include/netinet/in.h" 3 4
>struct sockaddr_in
> {
> sa_family_t sin_family;
> in_port_t sin_port;
> struct in_addr sin_addr;
>
>
> unsigned char sin_zero[sizeof (struct sockaddr) -
> (sizeof (unsigned short int)) -
> sizeof (in_port_t) -
> sizeof (struct in_addr)];
> };
>
>
>struct sockaddr_in6
> {
> sa_family_t sin6_family;
> in_port_t sin6_port;
> uint32_t sin6_flowinfo;
> struct in6_addr sin6_addr;
> uint32_t sin6_scope_id;
> };
>
>
>
>
>struct ip_mreq
> {
>
> struct in_addr imr_multiaddr;
>
>
> struct in_addr imr_interface;
> };
>
>struct ip_mreq_source
> {
>
> struct in_addr imr_multiaddr;
>
>
> struct in_addr imr_interface;
>
>
> struct in_addr imr_sourceaddr;
> };
>
>
>
>
>struct ipv6_mreq
> {
>
> struct in6_addr ipv6mr_multiaddr;
>
>
> unsigned int ipv6mr_interface;
> };
>
>
>
>
>struct group_req
> {
>
> uint32_t gr_interface;
>
>
> struct sockaddr_storage gr_group;
> };
>
>struct group_source_req
> {
>
> uint32_t gsr_interface;
>
>
> struct sockaddr_storage gsr_group;
>
>
> struct sockaddr_storage gsr_source;
> };
>
>
>
>struct ip_msfilter
> {
>
> struct in_addr imsf_multiaddr;
>
>
> struct in_addr imsf_interface;
>
>
> uint32_t imsf_fmode;
>
>
> uint32_t imsf_numsrc;
>
> struct in_addr imsf_slist[1];
> };
>
>
>
>
>
>struct group_filter
> {
>
> uint32_t gf_interface;
>
>
> struct sockaddr_storage gf_group;
>
>
> uint32_t gf_fmode;
>
>
> uint32_t gf_numsrc;
>
> struct sockaddr_storage gf_slist[1];
>};
># 354 "/usr/include/netinet/in.h" 3 4
># 1 "/usr/include/bits/in.h" 1 3 4
># 100 "/usr/include/bits/in.h" 3 4
>struct ip_opts
> {
> struct in_addr ip_dst;
> char ip_opts[40];
> };
>
>
>struct ip_mreqn
> {
> struct in_addr imr_multiaddr;
> struct in_addr imr_address;
> int imr_ifindex;
> };
>
>
>struct in_pktinfo
> {
> int ipi_ifindex;
> struct in_addr ipi_spec_dst;
> struct in_addr ipi_addr;
> };
># 355 "/usr/include/netinet/in.h" 2 3 4
># 363 "/usr/include/netinet/in.h" 3 4
>extern uint32_t ntohl (uint32_t __netlong) throw () __attribute__ ((__const__));
>extern uint16_t ntohs (uint16_t __netshort)
> throw () __attribute__ ((__const__));
>extern uint32_t htonl (uint32_t __hostlong)
> throw () __attribute__ ((__const__));
>extern uint16_t htons (uint16_t __hostshort)
> throw () __attribute__ ((__const__));
>
>
>
>
># 1 "/usr/include/bits/byteswap.h" 1 3 4
># 375 "/usr/include/netinet/in.h" 2 3 4
># 490 "/usr/include/netinet/in.h" 3 4
>extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in) throw ();
>
>
>extern int bindresvport6 (int __sockfd, struct sockaddr_in6 *__sock_in)
> throw ();
># 520 "/usr/include/netinet/in.h" 3 4
>struct cmsghdr;
>
>
>struct in6_pktinfo
> {
> struct in6_addr ipi6_addr;
> unsigned int ipi6_ifindex;
> };
>
>
>struct ip6_mtuinfo
> {
> struct sockaddr_in6 ip6m_addr;
> uint32_t ip6m_mtu;
> };
>
>
>
>extern int inet6_option_space (int __nbytes)
> throw () __attribute__ ((__deprecated__));
>extern int inet6_option_init (void *__bp, struct cmsghdr **__cmsgp,
> int __type) throw () __attribute__ ((__deprecated__));
>extern int inet6_option_append (struct cmsghdr *__cmsg,
> const uint8_t *__typep, int __multx,
> int __plusy) throw () __attribute__ ((__deprecated__));
>extern uint8_t *inet6_option_alloc (struct cmsghdr *__cmsg, int __datalen,
> int __multx, int __plusy)
> throw () __attribute__ ((__deprecated__));
>extern int inet6_option_next (const struct cmsghdr *__cmsg,
> uint8_t **__tptrp)
> throw () __attribute__ ((__deprecated__));
>extern int inet6_option_find (const struct cmsghdr *__cmsg,
> uint8_t **__tptrp, int __type)
> throw () __attribute__ ((__deprecated__));
>
>
>
>extern int inet6_opt_init (void *__extbuf, socklen_t __extlen) throw ();
>extern int inet6_opt_append (void *__extbuf, socklen_t __extlen, int __offset,
> uint8_t __type, socklen_t __len, uint8_t __align,
> void **__databufp) throw ();
>extern int inet6_opt_finish (void *__extbuf, socklen_t __extlen, int __offset)
> throw ();
>extern int inet6_opt_set_val (void *__databuf, int __offset, void *__val,
> socklen_t __vallen) throw ();
>extern int inet6_opt_next (void *__extbuf, socklen_t __extlen, int __offset,
> uint8_t *__typep, socklen_t *__lenp,
> void **__databufp) throw ();
>extern int inet6_opt_find (void *__extbuf, socklen_t __extlen, int __offset,
> uint8_t __type, socklen_t *__lenp,
> void **__databufp) throw ();
>extern int inet6_opt_get_val (void *__databuf, int __offset, void *__val,
> socklen_t __vallen) throw ();
>
>
>
>extern socklen_t inet6_rth_space (int __type, int __segments) throw ();
>extern void *inet6_rth_init (void *__bp, socklen_t __bp_len, int __type,
> int __segments) throw ();
>extern int inet6_rth_add (void *__bp, const struct in6_addr *__addr) throw ();
>extern int inet6_rth_reverse (const void *__in, void *__out) throw ();
>extern int inet6_rth_segments (const void *__bp) throw ();
>extern struct in6_addr *inet6_rth_getaddr (const void *__bp, int __index)
> throw ();
>
>
>
>
>
>extern int getipv4sourcefilter (int __s, struct in_addr __interface_addr,
> struct in_addr __group, uint32_t *__fmode,
> uint32_t *__numsrc, struct in_addr *__slist)
> throw ();
>
>
>extern int setipv4sourcefilter (int __s, struct in_addr __interface_addr,
> struct in_addr __group, uint32_t __fmode,
> uint32_t __numsrc,
> const struct in_addr *__slist)
> throw ();
>
>
>
>extern int getsourcefilter (int __s, uint32_t __interface_addr,
> const struct sockaddr *__group,
> socklen_t __grouplen, uint32_t *__fmode,
> uint32_t *__numsrc,
> struct sockaddr_storage *__slist) throw ();
>
>
>extern int setsourcefilter (int __s, uint32_t __interface_addr,
> const struct sockaddr *__group,
> socklen_t __grouplen, uint32_t __fmode,
> uint32_t __numsrc,
> const struct sockaddr_storage *__slist) throw ();
>
>
>}
># 28 "/usr/include/netdb.h" 2 3 4
>
>
>
>
># 1 "/usr/include/rpc/netdb.h" 1 3 4
># 42 "/usr/include/rpc/netdb.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 43 "/usr/include/rpc/netdb.h" 2 3 4
>
>extern "C" {
>
>struct rpcent
>{
> char *r_name;
> char **r_aliases;
> int r_number;
>};
>
>extern void setrpcent (int __stayopen) throw ();
>extern void endrpcent (void) throw ();
>extern struct rpcent *getrpcbyname (const char *__name) throw ();
>extern struct rpcent *getrpcbynumber (int __number) throw ();
>extern struct rpcent *getrpcent (void) throw ();
>
>
>extern int getrpcbyname_r (const char *__name, struct rpcent *__result_buf,
> char *__buffer, size_t __buflen,
> struct rpcent **__result) throw ();
>
>extern int getrpcbynumber_r (int __number, struct rpcent *__result_buf,
> char *__buffer, size_t __buflen,
> struct rpcent **__result) throw ();
>
>extern int getrpcent_r (struct rpcent *__result_buf, char *__buffer,
> size_t __buflen, struct rpcent **__result) throw ();
>
>
>}
># 33 "/usr/include/netdb.h" 2 3 4
>
>
>
>
># 1 "/usr/include/bits/siginfo.h" 1 3 4
># 24 "/usr/include/bits/siginfo.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 25 "/usr/include/bits/siginfo.h" 2 3 4
>
>
>
>
>
>
>
>typedef union sigval
> {
> int sival_int;
> void *sival_ptr;
> } sigval_t;
># 307 "/usr/include/bits/siginfo.h" 3 4
>typedef struct sigevent
> {
> sigval_t sigev_value;
> int sigev_signo;
> int sigev_notify;
>
> union
> {
> int _pad[((64 / sizeof (int)) - 4)];
>
>
>
> __pid_t _tid;
>
> struct
> {
> void (*_function) (sigval_t);
> pthread_attr_t *_attribute;
> } _sigev_thread;
> } _sigev_un;
> } sigevent_t;
>
>
>
>
>
>
>enum
>{
> SIGEV_SIGNAL = 0,
>
> SIGEV_NONE,
>
> SIGEV_THREAD,
>
>
> SIGEV_THREAD_ID = 4
>
>};
># 38 "/usr/include/netdb.h" 2 3 4
>
>
>
>
># 1 "/usr/include/bits/netdb.h" 1 3 4
># 26 "/usr/include/bits/netdb.h" 3 4
>struct netent
>{
> char *n_name;
> char **n_aliases;
> int n_addrtype;
> uint32_t n_net;
>};
># 43 "/usr/include/netdb.h" 2 3 4
># 53 "/usr/include/netdb.h" 3 4
>extern "C" {
>
>
>
>
>
>
>
>extern int *__h_errno_location (void) throw () __attribute__ ((__const__));
># 92 "/usr/include/netdb.h" 3 4
>extern void herror (const char *__str) throw ();
>
>
>extern const char *hstrerror (int __err_num) throw ();
>
>
>
>
>struct hostent
>{
> char *h_name;
> char **h_aliases;
> int h_addrtype;
> int h_length;
> char **h_addr_list;
>
>
>
>};
>
>
>
>
>
>
>extern void sethostent (int __stay_open);
>
>
>
>
>
>extern void endhostent (void);
>
>
>
>
>
>
>extern struct hostent *gethostent (void);
>
>
>
>
>
>
>extern struct hostent *gethostbyaddr (const void *__addr, __socklen_t __len,
> int __type);
>
>
>
>
>
>extern struct hostent *gethostbyname (const char *__name);
># 155 "/usr/include/netdb.h" 3 4
>extern struct hostent *gethostbyname2 (const char *__name, int __af);
># 167 "/usr/include/netdb.h" 3 4
>extern int gethostent_r (struct hostent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct hostent **__restrict __result,
> int *__restrict __h_errnop);
>
>extern int gethostbyaddr_r (const void *__restrict __addr, __socklen_t __len,
> int __type,
> struct hostent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct hostent **__restrict __result,
> int *__restrict __h_errnop);
>
>extern int gethostbyname_r (const char *__restrict __name,
> struct hostent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct hostent **__restrict __result,
> int *__restrict __h_errnop);
>
>extern int gethostbyname2_r (const char *__restrict __name, int __af,
> struct hostent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct hostent **__restrict __result,
> int *__restrict __h_errnop);
># 198 "/usr/include/netdb.h" 3 4
>extern void setnetent (int __stay_open);
>
>
>
>
>
>extern void endnetent (void);
>
>
>
>
>
>
>extern struct netent *getnetent (void);
>
>
>
>
>
>
>extern struct netent *getnetbyaddr (uint32_t __net, int __type);
>
>
>
>
>
>extern struct netent *getnetbyname (const char *__name);
># 237 "/usr/include/netdb.h" 3 4
>extern int getnetent_r (struct netent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct netent **__restrict __result,
> int *__restrict __h_errnop);
>
>extern int getnetbyaddr_r (uint32_t __net, int __type,
> struct netent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct netent **__restrict __result,
> int *__restrict __h_errnop);
>
>extern int getnetbyname_r (const char *__restrict __name,
> struct netent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct netent **__restrict __result,
> int *__restrict __h_errnop);
>
>
>
>
>struct servent
>{
> char *s_name;
> char **s_aliases;
> int s_port;
> char *s_proto;
>};
>
>
>
>
>
>
>extern void setservent (int __stay_open);
>
>
>
>
>
>extern void endservent (void);
>
>
>
>
>
>
>extern struct servent *getservent (void);
>
>
>
>
>
>
>extern struct servent *getservbyname (const char *__name, const char *__proto);
>
>
>
>
>
>
>extern struct servent *getservbyport (int __port, const char *__proto);
># 308 "/usr/include/netdb.h" 3 4
>extern int getservent_r (struct servent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct servent **__restrict __result);
>
>extern int getservbyname_r (const char *__restrict __name,
> const char *__restrict __proto,
> struct servent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct servent **__restrict __result);
>
>extern int getservbyport_r (int __port, const char *__restrict __proto,
> struct servent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct servent **__restrict __result);
>
>
>
>
>struct protoent
>{
> char *p_name;
> char **p_aliases;
> int p_proto;
>};
>
>
>
>
>
>
>extern void setprotoent (int __stay_open);
>
>
>
>
>
>extern void endprotoent (void);
>
>
>
>
>
>
>extern struct protoent *getprotoent (void);
>
>
>
>
>
>extern struct protoent *getprotobyname (const char *__name);
>
>
>
>
>
>extern struct protoent *getprotobynumber (int __proto);
># 374 "/usr/include/netdb.h" 3 4
>extern int getprotoent_r (struct protoent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct protoent **__restrict __result);
>
>extern int getprotobyname_r (const char *__restrict __name,
> struct protoent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct protoent **__restrict __result);
>
>extern int getprotobynumber_r (int __proto,
> struct protoent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct protoent **__restrict __result);
># 395 "/usr/include/netdb.h" 3 4
>extern int setnetgrent (const char *__netgroup);
>
>
>
>
>
>
>
>extern void endnetgrent (void);
># 412 "/usr/include/netdb.h" 3 4
>extern int getnetgrent (char **__restrict __hostp,
> char **__restrict __userp,
> char **__restrict __domainp);
># 423 "/usr/include/netdb.h" 3 4
>extern int innetgr (const char *__netgroup, const char *__host,
> const char *__user, const char *__domain);
>
>
>
>
>
>
>
>extern int getnetgrent_r (char **__restrict __hostp,
> char **__restrict __userp,
> char **__restrict __domainp,
> char *__restrict __buffer, size_t __buflen);
># 451 "/usr/include/netdb.h" 3 4
>extern int rcmd (char **__restrict __ahost, unsigned short int __rport,
> const char *__restrict __locuser,
> const char *__restrict __remuser,
> const char *__restrict __cmd, int *__restrict __fd2p);
># 463 "/usr/include/netdb.h" 3 4
>extern int rcmd_af (char **__restrict __ahost, unsigned short int __rport,
> const char *__restrict __locuser,
> const char *__restrict __remuser,
> const char *__restrict __cmd, int *__restrict __fd2p,
> sa_family_t __af);
># 479 "/usr/include/netdb.h" 3 4
>extern int rexec (char **__restrict __ahost, int __rport,
> const char *__restrict __name,
> const char *__restrict __pass,
> const char *__restrict __cmd, int *__restrict __fd2p);
># 491 "/usr/include/netdb.h" 3 4
>extern int rexec_af (char **__restrict __ahost, int __rport,
> const char *__restrict __name,
> const char *__restrict __pass,
> const char *__restrict __cmd, int *__restrict __fd2p,
> sa_family_t __af);
># 505 "/usr/include/netdb.h" 3 4
>extern int ruserok (const char *__rhost, int __suser,
> const char *__remuser, const char *__locuser);
># 515 "/usr/include/netdb.h" 3 4
>extern int ruserok_af (const char *__rhost, int __suser,
> const char *__remuser, const char *__locuser,
> sa_family_t __af);
># 528 "/usr/include/netdb.h" 3 4
>extern int iruserok (uint32_t __raddr, int __suser,
> const char *__remuser, const char *__locuser);
># 539 "/usr/include/netdb.h" 3 4
>extern int iruserok_af (const void *__raddr, int __suser,
> const char *__remuser, const char *__locuser,
> sa_family_t __af);
># 551 "/usr/include/netdb.h" 3 4
>extern int rresvport (int *__alport);
># 560 "/usr/include/netdb.h" 3 4
>extern int rresvport_af (int *__alport, sa_family_t __af);
>
>
>
>
>
>
>struct addrinfo
>{
> int ai_flags;
> int ai_family;
> int ai_socktype;
> int ai_protocol;
> socklen_t ai_addrlen;
> struct sockaddr *ai_addr;
> char *ai_canonname;
> struct addrinfo *ai_next;
>};
>
>
>
>struct gaicb
>{
> const char *ar_name;
> const char *ar_service;
> const struct addrinfo *ar_request;
> struct addrinfo *ar_result;
>
> int __return;
> int __unused[5];
>};
># 662 "/usr/include/netdb.h" 3 4
>extern int getaddrinfo (const char *__restrict __name,
> const char *__restrict __service,
> const struct addrinfo *__restrict __req,
> struct addrinfo **__restrict __pai);
>
>
>extern void freeaddrinfo (struct addrinfo *__ai) throw ();
>
>
>extern const char *gai_strerror (int __ecode) throw ();
>
>
>
>
>
>extern int getnameinfo (const struct sockaddr *__restrict __sa,
> socklen_t __salen, char *__restrict __host,
> socklen_t __hostlen, char *__restrict __serv,
> socklen_t __servlen, int __flags);
># 692 "/usr/include/netdb.h" 3 4
>extern int getaddrinfo_a (int __mode, struct gaicb *__list[],
> int __ent, struct sigevent *__restrict __sig);
># 703 "/usr/include/netdb.h" 3 4
>extern int gai_suspend (const struct gaicb *const __list[], int __ent,
> const struct timespec *__timeout);
>
>
>extern int gai_error (struct gaicb *__req) throw ();
>
>
>extern int gai_cancel (struct gaicb *__gaicbp) throw ();
>
>
>}
># 26 "/usr/include/boost/asio/error.hpp" 2 3 4
># 53 "/usr/include/boost/asio/error.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 54 "/usr/include/boost/asio/error.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace error {
>
>enum basic_errors
>{
>
> access_denied = 13,
>
>
> address_family_not_supported = 97,
>
>
> address_in_use = 98,
>
>
> already_connected = 106,
>
>
> already_started = 114,
>
>
> broken_pipe = 32
>
> ,
>
>
> connection_aborted = 103,
>
>
> connection_refused = 111,
>
>
> connection_reset = 104,
>
>
> bad_descriptor = 9,
>
>
> fault = 14,
>
>
> host_unreachable = 113,
>
>
> in_progress = 115,
>
>
> interrupted = 4,
>
>
> invalid_argument = 22,
>
>
> message_size = 90,
>
>
> name_too_long = 36,
>
>
> network_down = 100,
>
>
> network_reset = 102,
>
>
> network_unreachable = 101,
>
>
> no_descriptors = 24,
>
>
> no_buffer_space = 105,
>
>
> no_memory = 12
>
> ,
>
>
> no_permission = 1
>
> ,
>
>
> no_protocol_option = 92,
>
>
> not_connected = 107,
>
>
> not_socket = 88,
>
>
> operation_aborted = 125
>
> ,
>
>
> operation_not_supported = 95,
>
>
> shut_down = 108,
>
>
> timed_out = 110,
>
>
> try_again = 11
>
> ,
>
>
> would_block = 11
>};
>
>enum netdb_errors
>{
>
> host_not_found = 1,
>
>
> host_not_found_try_again = 2,
>
>
> no_data = 4,
>
>
> no_recovery = 3
>};
>
>enum addrinfo_errors
>{
>
> service_not_found = -8
>
> ,
>
>
> socket_type_not_supported = -7
>
>
>};
>
>enum misc_errors
>{
>
> already_open = 1,
>
>
> eof,
>
>
> not_found,
>
>
> fd_set_failure
>};
>
>inline const boost::system::error_category& get_system_category()
>{
> return boost::system::system_category();
>}
>
>
>
>extern inline
>const boost::system::error_category& get_netdb_category();
>
>extern inline
>const boost::system::error_category& get_addrinfo_category();
># 241 "/usr/include/boost/asio/error.hpp" 3 4
>extern inline
>const boost::system::error_category& get_misc_category();
>
>static const boost::system::error_category& system_category
> = boost::asio::error::get_system_category();
>static const boost::system::error_category& netdb_category
> = boost::asio::error::get_netdb_category();
>static const boost::system::error_category& addrinfo_category
> = boost::asio::error::get_addrinfo_category();
>static const boost::system::error_category& misc_category
> = boost::asio::error::get_misc_category();
>
>}
>}
>}
>
>namespace boost {
>namespace system {
>
>template<> struct is_error_code_enum<boost::asio::error::basic_errors>
>{
> static const bool value = true;
>};
>
>template<> struct is_error_code_enum<boost::asio::error::netdb_errors>
>{
> static const bool value = true;
>};
>
>template<> struct is_error_code_enum<boost::asio::error::addrinfo_errors>
>{
> static const bool value = true;
>};
>
>template<> struct is_error_code_enum<boost::asio::error::misc_errors>
>{
> static const bool value = true;
>};
>
>}
>}
>
>namespace boost {
>namespace asio {
>namespace error {
>
>inline boost::system::error_code make_error_code(basic_errors e)
>{
> return boost::system::error_code(
> static_cast<int>(e), get_system_category());
>}
>
>inline boost::system::error_code make_error_code(netdb_errors e)
>{
> return boost::system::error_code(
> static_cast<int>(e), get_netdb_category());
>}
>
>inline boost::system::error_code make_error_code(addrinfo_errors e)
>{
> return boost::system::error_code(
> static_cast<int>(e), get_addrinfo_category());
>}
>
>inline boost::system::error_code make_error_code(misc_errors e)
>{
> return boost::system::error_code(
> static_cast<int>(e), get_misc_category());
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 316 "/usr/include/boost/asio/error.hpp" 2 3 4
># 324 "/usr/include/boost/asio/error.hpp" 3 4
># 1 "/usr/include/boost/asio/impl/error.ipp" 1 3 4
># 19 "/usr/include/boost/asio/impl/error.ipp" 3 4
># 1 "/usr/include/boost/asio/error.hpp" 1 3 4
># 20 "/usr/include/boost/asio/impl/error.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/impl/error.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace error {
>
>
>
>namespace detail {
>
>class netdb_category : public boost::system::error_category
>{
>public:
> const char* name() const noexcept
> {
> return "asio.netdb";
> }
>
> std::string message(int value) const
> {
> if (value == error::host_not_found)
> return "Host not found (authoritative)";
> if (value == error::host_not_found_try_again)
> return "Host not found (non-authoritative), try again later";
> if (value == error::no_data)
> return "The query is valid, but it does not have associated data";
> if (value == error::no_recovery)
> return "A non-recoverable error occurred during database lookup";
> return "asio.netdb error";
> }
>};
>
>}
>
>const boost::system::error_category& get_netdb_category()
>{
> static detail::netdb_category instance;
> return instance;
>}
>
>namespace detail {
>
>class addrinfo_category : public boost::system::error_category
>{
>public:
> const char* name() const noexcept
> {
> return "asio.addrinfo";
> }
>
> std::string message(int value) const
> {
> if (value == error::service_not_found)
> return "Service not found";
> if (value == error::socket_type_not_supported)
> return "Socket type not supported";
> return "asio.addrinfo error";
> }
>};
>
>}
>
>const boost::system::error_category& get_addrinfo_category()
>{
> static detail::addrinfo_category instance;
> return instance;
>}
>
>
>
>namespace detail {
>
>class misc_category : public boost::system::error_category
>{
>public:
> const char* name() const noexcept
> {
> return "asio.misc";
> }
>
> std::string message(int value) const
> {
> if (value == error::already_open)
> return "Already open";
> if (value == error::eof)
> return "End of file";
> if (value == error::not_found)
> return "Element not found";
> if (value == error::fd_set_failure)
> return "The descriptor does not fit into the select call's fd_set";
> return "asio.misc error";
> }
>};
>
>}
>
>const boost::system::error_category& get_misc_category()
>{
> static detail::misc_category instance;
> return instance;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 128 "/usr/include/boost/asio/impl/error.ipp" 2 3 4
># 325 "/usr/include/boost/asio/error.hpp" 2 3 4
># 25 "/usr/include/boost/asio/detail/impl/posix_event.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/impl/posix_event.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>posix_event::posix_event()
> : signalled_(false)
>{
> int error = ::pthread_cond_init(&cond_, 0);
> boost::system::error_code ec(error,
> boost::asio::error::get_system_category());
> boost::asio::detail::throw_error(ec, "event");
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 46 "/usr/include/boost/asio/detail/impl/posix_event.ipp" 2 3 4
># 96 "/usr/include/boost/asio/detail/posix_event.hpp" 2 3 4
># 26 "/usr/include/boost/asio/detail/event.hpp" 2 3 4
>
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>
>
>typedef posix_event event;
>
>
>}
>}
>}
># 19 "/usr/include/boost/asio/detail/task_io_service_thread_info.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/op_queue.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/op_queue.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/op_queue.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Operation>
>class op_queue;
>
>class op_queue_access
>{
>public:
> template <typename Operation>
> static Operation* next(Operation* o)
> {
> return static_cast<Operation*>(o->next_);
> }
>
> template <typename Operation1, typename Operation2>
> static void next(Operation1*& o1, Operation2* o2)
> {
> o1->next_ = o2;
> }
>
> template <typename Operation>
> static void destroy(Operation* o)
> {
> o->destroy();
> }
>
> template <typename Operation>
> static Operation*& front(op_queue<Operation>& q)
> {
> return q.front_;
> }
>
> template <typename Operation>
> static Operation*& back(op_queue<Operation>& q)
> {
> return q.back_;
> }
>};
>
>template <typename Operation>
>class op_queue
> : private noncopyable
>{
>public:
>
> op_queue()
> : front_(0),
> back_(0)
> {
> }
>
>
> ~op_queue()
> {
> while (Operation* op = front_)
> {
> pop();
> op_queue_access::destroy(op);
> }
> }
>
>
> Operation* front()
> {
> return front_;
> }
>
>
> void pop()
> {
> if (front_)
> {
> Operation* tmp = front_;
> front_ = op_queue_access::next(front_);
> if (front_ == 0)
> back_ = 0;
> op_queue_access::next(tmp, static_cast<Operation*>(0));
> }
> }
>
>
> void push(Operation* h)
> {
> op_queue_access::next(h, static_cast<Operation*>(0));
> if (back_)
> {
> op_queue_access::next(back_, h);
> back_ = h;
> }
> else
> {
> front_ = back_ = h;
> }
> }
>
>
>
> template <typename OtherOperation>
> void push(op_queue<OtherOperation>& q)
> {
> if (Operation* other_front = op_queue_access::front(q))
> {
> if (back_)
> op_queue_access::next(back_, other_front);
> else
> front_ = other_front;
> back_ = op_queue_access::back(q);
> op_queue_access::front(q) = 0;
> op_queue_access::back(q) = 0;
> }
> }
>
>
> bool empty() const
> {
> return front_ == 0;
> }
>
>private:
> friend class op_queue_access;
>
>
> Operation* front_;
>
>
> Operation* back_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 157 "/usr/include/boost/asio/detail/op_queue.hpp" 2 3 4
># 20 "/usr/include/boost/asio/detail/task_io_service_thread_info.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/task_io_service_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/asio/detail/task_io_service_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>class task_io_service;
>class task_io_service_operation;
>struct task_io_service_thread_info;
>
>}
>}
>}
># 21 "/usr/include/boost/asio/detail/task_io_service_thread_info.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/thread_info_base.hpp" 1 3 4
># 18 "/usr/include/boost/asio/detail/thread_info_base.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/climits" 1 3 4
># 39 "/usr/include/c++/4.8.2/climits" 3 4
> 
># 40 "/usr/include/c++/4.8.2/climits" 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/syslimits.h" 1 3 4
>
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
># 168 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 3 4
># 1 "/usr/include/limits.h" 1 3 4
># 143 "/usr/include/limits.h" 3 4
># 1 "/usr/include/bits/posix1_lim.h" 1 3 4
># 160 "/usr/include/bits/posix1_lim.h" 3 4
># 1 "/usr/include/bits/local_lim.h" 1 3 4
># 38 "/usr/include/bits/local_lim.h" 3 4
># 1 "/usr/include/linux/limits.h" 1 3 4
># 39 "/usr/include/bits/local_lim.h" 2 3 4
># 161 "/usr/include/bits/posix1_lim.h" 2 3 4
># 144 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/posix2_lim.h" 1 3 4
># 148 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/xopen_lim.h" 1 3 4
># 33 "/usr/include/bits/xopen_lim.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 34 "/usr/include/bits/xopen_lim.h" 2 3 4
># 152 "/usr/include/limits.h" 2 3 4
># 169 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 2 3 4
># 8 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/syslimits.h" 2 3 4
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 2 3 4
># 42 "/usr/include/c++/4.8.2/climits" 2 3
># 19 "/usr/include/boost/asio/detail/thread_info_base.hpp" 2 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/detail/thread_info_base.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/thread_info_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class thread_info_base
> : private noncopyable
>{
>public:
> thread_info_base()
> : reusable_memory_(0)
> {
> }
>
> ~thread_info_base()
> {
> if (reusable_memory_)
> ::operator delete(reusable_memory_);
> }
>
> static void* allocate(thread_info_base* this_thread, std::size_t size)
> {
> if (this_thread && this_thread->reusable_memory_)
> {
> void* const pointer = this_thread->reusable_memory_;
> this_thread->reusable_memory_ = 0;
>
> unsigned char* const mem = static_cast<unsigned char*>(pointer);
> if (static_cast<std::size_t>(mem[0]) >= size)
> {
> mem[size] = mem[0];
> return pointer;
> }
>
> ::operator delete(pointer);
> }
>
> void* const pointer = ::operator new(size + 1);
> unsigned char* const mem = static_cast<unsigned char*>(pointer);
> mem[size] = (size <= (127 * 2 + 1)) ? static_cast<unsigned char>(size) : 0;
> return pointer;
> }
>
> static void deallocate(thread_info_base* this_thread,
> void* pointer, std::size_t size)
> {
> if (size <= (127 * 2 + 1))
> {
> if (this_thread && this_thread->reusable_memory_ == 0)
> {
> unsigned char* const mem = static_cast<unsigned char*>(pointer);
> mem[0] = mem[size];
> this_thread->reusable_memory_ = pointer;
> return;
> }
> }
>
> ::operator delete(pointer);
> }
>
>private:
> void* reusable_memory_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 92 "/usr/include/boost/asio/detail/thread_info_base.hpp" 2 3 4
># 22 "/usr/include/boost/asio/detail/task_io_service_thread_info.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/task_io_service_thread_info.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>struct task_io_service_thread_info : public thread_info_base
>{
> event* wakeup_event;
> op_queue<task_io_service_operation> private_op_queue;
> long private_outstanding_work;
> task_io_service_thread_info* next;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 42 "/usr/include/boost/asio/detail/task_io_service_thread_info.hpp" 2 3 4
># 28 "/usr/include/boost/asio/impl/handler_alloc_hook.ipp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 32 "/usr/include/boost/asio/impl/handler_alloc_hook.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>void* asio_handler_allocate(std::size_t size, ...)
>{
>
>
>
>
>
> typedef detail::task_io_service io_service_impl;
> typedef detail::task_io_service_thread_info thread_info;
>
> typedef detail::call_stack<io_service_impl, thread_info> call_stack;
> return thread_info::allocate(call_stack::top(), size);
>
>
>
>}
>
>void asio_handler_deallocate(void* pointer, std::size_t size, ...)
>{
>
>
>
>
>
> typedef detail::task_io_service io_service_impl;
> typedef detail::task_io_service_thread_info thread_info;
>
> typedef detail::call_stack<io_service_impl, thread_info> call_stack;
> thread_info::deallocate(call_stack::top(), pointer, size);
>
>
>
>
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 75 "/usr/include/boost/asio/impl/handler_alloc_hook.ipp" 2 3 4
># 81 "/usr/include/boost/asio/handler_alloc_hook.hpp" 2 3 4
># 22 "/usr/include/boost/asio/detail/handler_alloc_helpers.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/handler_alloc_helpers.hpp" 2 3 4
>
>
>
>
>namespace boost_asio_handler_alloc_helpers {
>
>template <typename Handler>
>inline void* allocate(std::size_t s, Handler& h)
>{
>
>
>
> using boost::asio::asio_handler_allocate;
> return asio_handler_allocate(s, boost::asio::detail::addressof(h));
>
>}
>
>template <typename Handler>
>inline void deallocate(void* p, std::size_t s, Handler& h)
>{
>
>
>
> using boost::asio::asio_handler_deallocate;
> asio_handler_deallocate(p, s, boost::asio::detail::addressof(h));
>
>}
>
>}
># 80 "/usr/include/boost/asio/detail/handler_alloc_helpers.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 81 "/usr/include/boost/asio/detail/handler_alloc_helpers.hpp" 2 3 4
># 20 "/usr/include/boost/asio/detail/bind_handler.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/handler_cont_helpers.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/handler_cont_helpers.hpp" 3 4
># 1 "/usr/include/boost/asio/handler_continuation_hook.hpp" 1 3 4
># 20 "/usr/include/boost/asio/handler_continuation_hook.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 21 "/usr/include/boost/asio/handler_continuation_hook.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 46 "/usr/include/boost/asio/handler_continuation_hook.hpp" 3 4
>inline bool asio_handler_is_continuation(...)
>{
> return false;
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 55 "/usr/include/boost/asio/handler_continuation_hook.hpp" 2 3 4
># 21 "/usr/include/boost/asio/detail/handler_cont_helpers.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/handler_cont_helpers.hpp" 2 3 4
>
>
>
>
>namespace boost_asio_handler_cont_helpers {
>
>template <typename Context>
>inline bool is_continuation(Context& context)
>{
>
>
>
> using boost::asio::asio_handler_is_continuation;
> return asio_handler_is_continuation(
> boost::asio::detail::addressof(context));
>
>}
>
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 44 "/usr/include/boost/asio/detail/handler_cont_helpers.hpp" 2 3 4
># 21 "/usr/include/boost/asio/detail/bind_handler.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/handler_invoke_helpers.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/handler_invoke_helpers.hpp" 3 4
># 1 "/usr/include/boost/asio/handler_invoke_hook.hpp" 1 3 4
># 20 "/usr/include/boost/asio/handler_invoke_hook.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 21 "/usr/include/boost/asio/handler_invoke_hook.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 61 "/usr/include/boost/asio/handler_invoke_hook.hpp" 3 4
>template <typename Function>
>inline void asio_handler_invoke(Function function, ...)
>{
> function();
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/handler_invoke_hook.hpp" 2 3 4
># 21 "/usr/include/boost/asio/detail/handler_invoke_helpers.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/handler_invoke_helpers.hpp" 2 3 4
>
>
>
>
>namespace boost_asio_handler_invoke_helpers {
>
>template <typename Function, typename Context>
>inline void invoke(Function& function, Context& context)
>{
>
>
>
>
> using boost::asio::asio_handler_invoke;
> asio_handler_invoke(function, boost::asio::detail::addressof(context));
>
>}
>
>template <typename Function, typename Context>
>inline void invoke(const Function& function, Context& context)
>{
>
>
>
>
> using boost::asio::asio_handler_invoke;
> asio_handler_invoke(function, boost::asio::detail::addressof(context));
>
>}
>
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 56 "/usr/include/boost/asio/detail/handler_invoke_helpers.hpp" 2 3 4
># 22 "/usr/include/boost/asio/detail/bind_handler.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/bind_handler.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Handler, typename Arg1>
>class binder1
>{
>public:
> binder1(const Handler& handler, const Arg1& arg1)
> : handler_(handler),
> arg1_(arg1)
> {
> }
>
> binder1(Handler& handler, const Arg1& arg1)
> : handler_(static_cast<Handler&&>(handler)),
> arg1_(arg1)
> {
> }
>
> void operator()()
> {
> handler_(static_cast<const Arg1&>(arg1_));
> }
>
> void operator()() const
> {
> handler_(arg1_);
> }
>
>
> Handler handler_;
> Arg1 arg1_;
>};
>
>template <typename Handler, typename Arg1>
>inline void* asio_handler_allocate(std::size_t size,
> binder1<Handler, Arg1>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> binder1<Handler, Arg1>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1>
>inline bool asio_handler_is_continuation(
> binder1<Handler, Arg1>* this_handler)
>{
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1>
>inline void asio_handler_invoke(Function& function,
> binder1<Handler, Arg1>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1>
>inline void asio_handler_invoke(const Function& function,
> binder1<Handler, Arg1>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1>
>inline binder1<Handler, Arg1> bind_handler(Handler handler,
> const Arg1& arg1)
>{
> return binder1<Handler, Arg1>(handler, arg1);
>}
>
>template <typename Handler, typename Arg1, typename Arg2>
>class binder2
>{
>public:
> binder2(const Handler& handler, const Arg1& arg1, const Arg2& arg2)
> : handler_(handler),
> arg1_(arg1),
> arg2_(arg2)
> {
> }
>
> binder2(Handler& handler, const Arg1& arg1, const Arg2& arg2)
> : handler_(static_cast<Handler&&>(handler)),
> arg1_(arg1),
> arg2_(arg2)
> {
> }
>
> void operator()()
> {
> handler_(static_cast<const Arg1&>(arg1_),
> static_cast<const Arg2&>(arg2_));
> }
>
> void operator()() const
> {
> handler_(arg1_, arg2_);
> }
>
>
> Handler handler_;
> Arg1 arg1_;
> Arg2 arg2_;
>};
>
>template <typename Handler, typename Arg1, typename Arg2>
>inline void* asio_handler_allocate(std::size_t size,
> binder2<Handler, Arg1, Arg2>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> binder2<Handler, Arg1, Arg2>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2>
>inline bool asio_handler_is_continuation(
> binder2<Handler, Arg1, Arg2>* this_handler)
>{
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1, typename Arg2>
>inline void asio_handler_invoke(Function& function,
> binder2<Handler, Arg1, Arg2>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1, typename Arg2>
>inline void asio_handler_invoke(const Function& function,
> binder2<Handler, Arg1, Arg2>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2>
>inline binder2<Handler, Arg1, Arg2> bind_handler(Handler handler,
> const Arg1& arg1, const Arg2& arg2)
>{
> return binder2<Handler, Arg1, Arg2>(handler, arg1, arg2);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
>class binder3
>{
>public:
> binder3(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
> const Arg3& arg3)
> : handler_(handler),
> arg1_(arg1),
> arg2_(arg2),
> arg3_(arg3)
> {
> }
>
> binder3(Handler& handler, const Arg1& arg1, const Arg2& arg2,
> const Arg3& arg3)
> : handler_(static_cast<Handler&&>(handler)),
> arg1_(arg1),
> arg2_(arg2),
> arg3_(arg3)
> {
> }
>
> void operator()()
> {
> handler_(static_cast<const Arg1&>(arg1_),
> static_cast<const Arg2&>(arg2_),
> static_cast<const Arg3&>(arg3_));
> }
>
> void operator()() const
> {
> handler_(arg1_, arg2_, arg3_);
> }
>
>
> Handler handler_;
> Arg1 arg1_;
> Arg2 arg2_;
> Arg3 arg3_;
>};
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
>inline void* asio_handler_allocate(std::size_t size,
> binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
>inline bool asio_handler_is_continuation(
> binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
>{
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1, typename Arg2,
> typename Arg3>
>inline void asio_handler_invoke(Function& function,
> binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1, typename Arg2,
> typename Arg3>
>inline void asio_handler_invoke(const Function& function,
> binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
>inline binder3<Handler, Arg1, Arg2, Arg3> bind_handler(Handler handler,
> const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
>{
> return binder3<Handler, Arg1, Arg2, Arg3>(handler, arg1, arg2, arg3);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
> typename Arg4>
>class binder4
>{
>public:
> binder4(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
> const Arg3& arg3, const Arg4& arg4)
> : handler_(handler),
> arg1_(arg1),
> arg2_(arg2),
> arg3_(arg3),
> arg4_(arg4)
> {
> }
>
> binder4(Handler& handler, const Arg1& arg1, const Arg2& arg2,
> const Arg3& arg3, const Arg4& arg4)
> : handler_(static_cast<Handler&&>(handler)),
> arg1_(arg1),
> arg2_(arg2),
> arg3_(arg3),
> arg4_(arg4)
> {
> }
>
> void operator()()
> {
> handler_(static_cast<const Arg1&>(arg1_),
> static_cast<const Arg2&>(arg2_),
> static_cast<const Arg3&>(arg3_),
> static_cast<const Arg4&>(arg4_));
> }
>
> void operator()() const
> {
> handler_(arg1_, arg2_, arg3_, arg4_);
> }
>
>
> Handler handler_;
> Arg1 arg1_;
> Arg2 arg2_;
> Arg3 arg3_;
> Arg4 arg4_;
>};
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
> typename Arg4>
>inline void* asio_handler_allocate(std::size_t size,
> binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
> typename Arg4>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
> typename Arg4>
>inline bool asio_handler_is_continuation(
> binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
>{
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1, typename Arg2,
> typename Arg3, typename Arg4>
>inline void asio_handler_invoke(Function& function,
> binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1, typename Arg2,
> typename Arg3, typename Arg4>
>inline void asio_handler_invoke(const Function& function,
> binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
> typename Arg4>
>inline binder4<Handler, Arg1, Arg2, Arg3, Arg4> bind_handler(
> Handler handler, const Arg1& arg1, const Arg2& arg2,
> const Arg3& arg3, const Arg4& arg4)
>{
> return binder4<Handler, Arg1, Arg2, Arg3, Arg4>(handler, arg1, arg2, arg3,
> arg4);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
> typename Arg4, typename Arg5>
>class binder5
>{
>public:
> binder5(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
> const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
> : handler_(handler),
> arg1_(arg1),
> arg2_(arg2),
> arg3_(arg3),
> arg4_(arg4),
> arg5_(arg5)
> {
> }
>
> binder5(Handler& handler, const Arg1& arg1, const Arg2& arg2,
> const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
> : handler_(static_cast<Handler&&>(handler)),
> arg1_(arg1),
> arg2_(arg2),
> arg3_(arg3),
> arg4_(arg4),
> arg5_(arg5)
> {
> }
>
> void operator()()
> {
> handler_(static_cast<const Arg1&>(arg1_),
> static_cast<const Arg2&>(arg2_),
> static_cast<const Arg3&>(arg3_),
> static_cast<const Arg4&>(arg4_),
> static_cast<const Arg5&>(arg5_));
> }
>
> void operator()() const
> {
> handler_(arg1_, arg2_, arg3_, arg4_, arg5_);
> }
>
>
> Handler handler_;
> Arg1 arg1_;
> Arg2 arg2_;
> Arg3 arg3_;
> Arg4 arg4_;
> Arg5 arg5_;
>};
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
> typename Arg4, typename Arg5>
>inline void* asio_handler_allocate(std::size_t size,
> binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
> typename Arg4, typename Arg5>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
> typename Arg4, typename Arg5>
>inline bool asio_handler_is_continuation(
> binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
>{
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1, typename Arg2,
> typename Arg3, typename Arg4, typename Arg5>
>inline void asio_handler_invoke(Function& function,
> binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1, typename Arg2,
> typename Arg3, typename Arg4, typename Arg5>
>inline void asio_handler_invoke(const Function& function,
> binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
> typename Arg4, typename Arg5>
>inline binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5> bind_handler(
> Handler handler, const Arg1& arg1, const Arg2& arg2,
> const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
>{
> return binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>(handler, arg1, arg2,
> arg3, arg4, arg5);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 490 "/usr/include/boost/asio/detail/bind_handler.hpp" 2 3 4
># 19 "/usr/include/boost/asio/detail/wrapped_handler.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/wrapped_handler.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>struct is_continuation_delegated
>{
> template <typename Dispatcher, typename Handler>
> bool operator()(Dispatcher&, Handler& handler) const
> {
> return boost_asio_handler_cont_helpers::is_continuation(handler);
> }
>};
>
>struct is_continuation_if_running
>{
> template <typename Dispatcher, typename Handler>
> bool operator()(Dispatcher& dispatcher, Handler&) const
> {
> return dispatcher.running_in_this_thread();
> }
>};
>
>template <typename Dispatcher, typename Handler,
> typename IsContinuation = is_continuation_delegated>
>class wrapped_handler
>{
>public:
> typedef void result_type;
>
> wrapped_handler(Dispatcher dispatcher, Handler& handler)
> : dispatcher_(dispatcher),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
>
> wrapped_handler(const wrapped_handler& other)
> : dispatcher_(other.dispatcher_),
> handler_(other.handler_)
> {
> }
>
> wrapped_handler(wrapped_handler&& other)
> : dispatcher_(other.dispatcher_),
> handler_(static_cast<Handler&&>(other.handler_))
> {
> }
>
>
> void operator()()
> {
> dispatcher_.dispatch(handler_);
> }
>
> void operator()() const
> {
> dispatcher_.dispatch(handler_);
> }
>
> template <typename Arg1>
> void operator()(const Arg1& arg1)
> {
> dispatcher_.dispatch(detail::bind_handler(handler_, arg1));
> }
>
> template <typename Arg1>
> void operator()(const Arg1& arg1) const
> {
> dispatcher_.dispatch(detail::bind_handler(handler_, arg1));
> }
>
> template <typename Arg1, typename Arg2>
> void operator()(const Arg1& arg1, const Arg2& arg2)
> {
> dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2));
> }
>
> template <typename Arg1, typename Arg2>
> void operator()(const Arg1& arg1, const Arg2& arg2) const
> {
> dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2));
> }
>
> template <typename Arg1, typename Arg2, typename Arg3>
> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
> {
> dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2, arg3));
> }
>
> template <typename Arg1, typename Arg2, typename Arg3>
> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3) const
> {
> dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2, arg3));
> }
>
> template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
> const Arg4& arg4)
> {
> dispatcher_.dispatch(
> detail::bind_handler(handler_, arg1, arg2, arg3, arg4));
> }
>
> template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
> const Arg4& arg4) const
> {
> dispatcher_.dispatch(
> detail::bind_handler(handler_, arg1, arg2, arg3, arg4));
> }
>
> template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
> typename Arg5>
> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
> const Arg4& arg4, const Arg5& arg5)
> {
> dispatcher_.dispatch(
> detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5));
> }
>
> template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
> typename Arg5>
> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
> const Arg4& arg4, const Arg5& arg5) const
> {
> dispatcher_.dispatch(
> detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5));
> }
>
>
> Dispatcher dispatcher_;
> Handler handler_;
>};
>
>template <typename Handler, typename Context>
>class rewrapped_handler
>{
>public:
> explicit rewrapped_handler(Handler& handler, const Context& context)
> : context_(context),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
> explicit rewrapped_handler(const Handler& handler, const Context& context)
> : context_(context),
> handler_(handler)
> {
> }
>
>
> rewrapped_handler(const rewrapped_handler& other)
> : context_(other.context_),
> handler_(other.handler_)
> {
> }
>
> rewrapped_handler(rewrapped_handler&& other)
> : context_(static_cast<Context&&>(other.context_)),
> handler_(static_cast<Handler&&>(other.handler_))
> {
> }
>
>
> void operator()()
> {
> handler_();
> }
>
> void operator()() const
> {
> handler_();
> }
>
>
> Context context_;
> Handler handler_;
>};
>
>template <typename Dispatcher, typename Handler, typename IsContinuation>
>inline void* asio_handler_allocate(std::size_t size,
> wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
>}
>
>template <typename Dispatcher, typename Handler, typename IsContinuation>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
>}
>
>template <typename Dispatcher, typename Handler, typename IsContinuation>
>inline bool asio_handler_is_continuation(
> wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
>{
> return IsContinuation()(this_handler->dispatcher_, this_handler->handler_);
>}
>
>template <typename Function, typename Dispatcher,
> typename Handler, typename IsContinuation>
>inline void asio_handler_invoke(Function& function,
> wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
>{
> this_handler->dispatcher_.dispatch(
> rewrapped_handler<Function, Handler>(
> function, this_handler->handler_));
>}
>
>template <typename Function, typename Dispatcher,
> typename Handler, typename IsContinuation>
>inline void asio_handler_invoke(const Function& function,
> wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
>{
> this_handler->dispatcher_.dispatch(
> rewrapped_handler<Function, Handler>(
> function, this_handler->handler_));
>}
>
>template <typename Handler, typename Context>
>inline void* asio_handler_allocate(std::size_t size,
> rewrapped_handler<Handler, Context>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->context_);
>}
>
>template <typename Handler, typename Context>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> rewrapped_handler<Handler, Context>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->context_);
>}
>
>template <typename Dispatcher, typename Context>
>inline bool asio_handler_is_continuation(
> rewrapped_handler<Dispatcher, Context>* this_handler)
>{
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Context>
>inline void asio_handler_invoke(Function& function,
> rewrapped_handler<Handler, Context>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->context_);
>}
>
>template <typename Function, typename Handler, typename Context>
>inline void asio_handler_invoke(const Function& function,
> rewrapped_handler<Handler, Context>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->context_);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 292 "/usr/include/boost/asio/detail/wrapped_handler.hpp" 2 3 4
># 26 "/usr/include/boost/asio/io_service.hpp" 2 3 4
># 41 "/usr/include/boost/asio/io_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 42 "/usr/include/boost/asio/io_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>class io_service;
>template <typename Service> Service& use_service(io_service& ios);
>template <typename Service> void add_service(io_service& ios, Service* svc);
>template <typename Service> bool has_service(io_service& ios);
>
>
>
>
>namespace detail { typedef task_io_service io_service_impl; }
># 188 "/usr/include/boost/asio/io_service.hpp" 3 4
>class io_service
> : private noncopyable
>{
>private:
> typedef detail::io_service_impl impl_type;
>
>
>
>
>public:
> class work;
> friend class work;
>
> class id;
>
> class service;
>
> class strand;
>
>
> inline io_service();
># 217 "/usr/include/boost/asio/io_service.hpp" 3 4
> inline explicit io_service(std::size_t concurrency_hint);
># 251 "/usr/include/boost/asio/io_service.hpp" 3 4
> inline ~io_service();
># 279 "/usr/include/boost/asio/io_service.hpp" 3 4
> inline std::size_t run();
># 307 "/usr/include/boost/asio/io_service.hpp" 3 4
> inline std::size_t run(boost::system::error_code& ec);
># 323 "/usr/include/boost/asio/io_service.hpp" 3 4
> inline std::size_t run_one();
># 339 "/usr/include/boost/asio/io_service.hpp" 3 4
> inline std::size_t run_one(boost::system::error_code& ec);
># 351 "/usr/include/boost/asio/io_service.hpp" 3 4
> inline std::size_t poll();
># 363 "/usr/include/boost/asio/io_service.hpp" 3 4
> inline std::size_t poll(boost::system::error_code& ec);
># 375 "/usr/include/boost/asio/io_service.hpp" 3 4
> inline std::size_t poll_one();
># 387 "/usr/include/boost/asio/io_service.hpp" 3 4
> inline std::size_t poll_one(boost::system::error_code& ec);
># 396 "/usr/include/boost/asio/io_service.hpp" 3 4
> inline void stop();
># 408 "/usr/include/boost/asio/io_service.hpp" 3 4
> inline bool stopped() const;
># 421 "/usr/include/boost/asio/io_service.hpp" 3 4
> inline void reset();
># 444 "/usr/include/boost/asio/io_service.hpp" 3 4
> template <typename CompletionHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
> dispatch(CompletionHandler&& handler);
># 470 "/usr/include/boost/asio/io_service.hpp" 3 4
> template <typename CompletionHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
> post(CompletionHandler&& handler);
># 496 "/usr/include/boost/asio/io_service.hpp" 3 4
> template <typename Handler>
>
>
>
> detail::wrapped_handler<io_service&, Handler>
>
> wrap(Handler handler);
>
>
> enum fork_event
> {
>
> fork_prepare,
>
>
> fork_parent,
>
>
> fork_child
> };
># 557 "/usr/include/boost/asio/io_service.hpp" 3 4
> inline void notify_fork(boost::asio::io_service::fork_event event);
># 570 "/usr/include/boost/asio/io_service.hpp" 3 4
> template <typename Service>
> friend Service& use_service(io_service& ios);
># 590 "/usr/include/boost/asio/io_service.hpp" 3 4
> template <typename Service>
> friend void add_service(io_service& ios, Service* svc);
># 602 "/usr/include/boost/asio/io_service.hpp" 3 4
> template <typename Service>
> friend bool has_service(io_service& ios);
>
>private:
># 614 "/usr/include/boost/asio/io_service.hpp" 3 4
> boost::asio::detail::service_registry* service_registry_;
>
>
> impl_type& impl_;
>};
># 630 "/usr/include/boost/asio/io_service.hpp" 3 4
>class io_service::work
>{
>public:
>
>
>
>
>
>
> explicit work(boost::asio::io_service& io_service);
>
>
>
>
>
>
>
> work(const work& other);
>
>
>
>
>
>
>
> ~work();
>
>
> boost::asio::io_service& get_io_service();
>
>private:
>
> void operator=(const work& other);
>
>
> detail::io_service_impl& io_service_impl_;
>};
>
>
>class io_service::id
> : private noncopyable
>{
>public:
>
> id() {}
>};
>
>
>class io_service::service
> : private noncopyable
>{
>public:
>
> boost::asio::io_service& get_io_service();
>
>protected:
>
>
>
>
> inline service(boost::asio::io_service& owner);
>
>
> inline virtual ~service();
>
>private:
>
> virtual void shutdown_service() = 0;
>
>
>
>
>
>
>
> inline virtual void fork_service(
> boost::asio::io_service::fork_event event);
>
> friend class boost::asio::detail::service_registry;
> struct key
> {
> key() : type_info_(0), id_(0) {}
> const std::type_info* type_info_;
> const boost::asio::io_service::id* id_;
> } key_;
>
> boost::asio::io_service& owner_;
> service* next_;
>};
>
>
>class service_already_exists
> : public std::logic_error
>{
>public:
> inline service_already_exists();
>};
>
>
>
>class invalid_service_owner
> : public std::logic_error
>{
>public:
> inline invalid_service_owner();
>};
>
>namespace detail {
>
>
>template <typename Type>
>class service_id
> : public boost::asio::io_service::id
>{
>};
>
>
>template <typename Type>
>class service_base
> : public boost::asio::io_service::service
>{
>public:
> static boost::asio::detail::service_id<Type> id;
>
>
> service_base(boost::asio::io_service& io_service)
> : boost::asio::io_service::service(io_service)
> {
> }
>};
>
>template <typename Type>
>boost::asio::detail::service_id<Type> service_base<Type>::id;
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 769 "/usr/include/boost/asio/io_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/io_service.hpp" 1 3 4
># 18 "/usr/include/boost/asio/impl/io_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/handler_type_requirements.hpp" 1 3 4
># 56 "/usr/include/boost/asio/detail/handler_type_requirements.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>
>template <typename Handler>
>auto zero_arg_handler_test(Handler h, void*)
> -> decltype(
> sizeof(Handler(static_cast<const Handler&>(h))),
> ((h)()),
> char(0));
>
>template <typename Handler>
>char (&zero_arg_handler_test(Handler, ...))[2];
>
>template <typename Handler, typename Arg1>
>auto one_arg_handler_test(Handler h, Arg1* a1)
> -> decltype(
> sizeof(Handler(static_cast<const Handler&>(h))),
> ((h)(*a1)),
> char(0));
>
>template <typename Handler>
>char (&one_arg_handler_test(Handler h, ...))[2];
>
>template <typename Handler, typename Arg1, typename Arg2>
>auto two_arg_handler_test(Handler h, Arg1* a1, Arg2* a2)
> -> decltype(
> sizeof(Handler(static_cast<const Handler&>(h))),
> ((h)(*a1, *a2)),
> char(0));
>
>template <typename Handler>
>char (&two_arg_handler_test(Handler, ...))[2];
># 103 "/usr/include/boost/asio/detail/handler_type_requirements.hpp" 3 4
>template <typename T> T& lvref();
>template <typename T> T& lvref(T);
>template <typename T> const T& clvref();
>template <typename T> const T& clvref(T);
>template <typename T> char argbyv(T);
>
>template <int>
>struct handler_type_requirements
>{
>};
># 476 "/usr/include/boost/asio/detail/handler_type_requirements.hpp" 3 4
>}
>}
>}
># 19 "/usr/include/boost/asio/impl/io_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/service_registry.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/service_registry.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/mutex.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/mutex.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_mutex.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/posix_mutex.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/scoped_lock.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/scoped_lock.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/scoped_lock.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>template <typename Mutex>
>class scoped_lock
> : private noncopyable
>{
>public:
>
> enum adopt_lock_t { adopt_lock };
>
>
> scoped_lock(Mutex& m, adopt_lock_t)
> : mutex_(m),
> locked_(true)
> {
> }
>
>
> explicit scoped_lock(Mutex& m)
> : mutex_(m)
> {
> mutex_.lock();
> locked_ = true;
> }
>
>
> ~scoped_lock()
> {
> if (locked_)
> mutex_.unlock();
> }
>
>
> void lock()
> {
> if (!locked_)
> {
> mutex_.lock();
> locked_ = true;
> }
> }
>
>
> void unlock()
> {
> if (locked_)
> {
> mutex_.unlock();
> locked_ = false;
> }
> }
>
>
> bool locked() const
> {
> return locked_;
> }
>
>
> Mutex& mutex()
> {
> return mutex_;
> }
>
>private:
>
> Mutex& mutex_;
>
>
> bool locked_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 102 "/usr/include/boost/asio/detail/scoped_lock.hpp" 2 3 4
># 25 "/usr/include/boost/asio/detail/posix_mutex.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/posix_mutex.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class posix_event;
>
>class posix_mutex
> : private noncopyable
>{
>public:
> typedef boost::asio::detail::scoped_lock<posix_mutex> scoped_lock;
>
>
> inline posix_mutex();
>
>
> ~posix_mutex()
> {
> ::pthread_mutex_destroy(&mutex_);
> }
>
>
> void lock()
> {
> (void)::pthread_mutex_lock(&mutex_);
> }
>
>
> void unlock()
> {
> (void)::pthread_mutex_unlock(&mutex_);
> }
>
>private:
> friend class posix_event;
> ::pthread_mutex_t mutex_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/posix_mutex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/posix_mutex.ipp" 1 3 4
># 22 "/usr/include/boost/asio/detail/impl/posix_mutex.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_mutex.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/impl/posix_mutex.ipp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/impl/posix_mutex.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>posix_mutex::posix_mutex()
>{
> int error = ::pthread_mutex_init(&mutex_, 0);
> boost::system::error_code ec(error,
> boost::asio::error::get_system_category());
> boost::asio::detail::throw_error(ec, "mutex");
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 45 "/usr/include/boost/asio/detail/impl/posix_mutex.ipp" 2 3 4
># 74 "/usr/include/boost/asio/detail/posix_mutex.hpp" 2 3 4
># 26 "/usr/include/boost/asio/detail/mutex.hpp" 2 3 4
>
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>
>
>typedef posix_mutex mutex;
>
>
>}
>}
>}
># 21 "/usr/include/boost/asio/detail/service_registry.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/io_service.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/service_registry.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/service_registry.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>#pragma GCC visibility push (default)
>
>
>
>template <typename T>
>class typeid_wrapper {};
>
>
>
>#pragma GCC visibility pop
>
>
>
>class service_registry
> : private noncopyable
>{
>public:
>
> template <typename Service, typename Arg>
> service_registry(boost::asio::io_service& o,
> Service* initial_service, Arg arg);
>
>
> inline ~service_registry();
>
>
> inline void notify_fork(boost::asio::io_service::fork_event fork_ev);
>
>
>
> template <typename Service>
> Service& first_service();
>
>
>
>
> template <typename Service>
> Service& use_service();
>
>
>
> template <typename Service>
> void add_service(Service* new_service);
>
>
> template <typename Service>
> bool has_service() const;
>
>private:
>
> inline static void init_key(
> boost::asio::io_service::service::key& key,
> const boost::asio::io_service::id& id);
>
>
>
> template <typename Service>
> static void init_key(boost::asio::io_service::service::key& key,
> const boost::asio::detail::service_id<Service>& );
>
>
>
> inline static bool keys_match(
> const boost::asio::io_service::service::key& key1,
> const boost::asio::io_service::service::key& key2);
>
>
> typedef boost::asio::io_service::service*
> (*factory_type)(boost::asio::io_service&);
>
>
> template <typename Service>
> static boost::asio::io_service::service* create(
> boost::asio::io_service& owner);
>
>
> inline static void destroy(
> boost::asio::io_service::service* service);
>
>
> struct auto_service_ptr;
> friend struct auto_service_ptr;
> struct auto_service_ptr
> {
> boost::asio::io_service::service* ptr_;
> ~auto_service_ptr() { destroy(ptr_); }
> };
>
>
>
>
> inline boost::asio::io_service::service* do_use_service(
> const boost::asio::io_service::service::key& key,
> factory_type factory);
>
>
>
> inline void do_add_service(
> const boost::asio::io_service::service::key& key,
> boost::asio::io_service::service* new_service);
>
>
> inline bool do_has_service(
> const boost::asio::io_service::service::key& key) const;
>
>
> mutable boost::asio::detail::mutex mutex_;
>
>
> boost::asio::io_service& owner_;
>
>
> boost::asio::io_service::service* first_service_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 152 "/usr/include/boost/asio/detail/service_registry.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/service_registry.hpp" 1 3 4
># 18 "/usr/include/boost/asio/detail/impl/service_registry.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/impl/service_registry.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Service, typename Arg>
>service_registry::service_registry(
> boost::asio::io_service& o, Service*, Arg arg)
> : owner_(o),
> first_service_(new Service(o, arg))
>{
> boost::asio::io_service::service::key key;
> init_key(key, Service::id);
> first_service_->key_ = key;
> first_service_->next_ = 0;
>}
>
>template <typename Service>
>Service& service_registry::first_service()
>{
> return *static_cast<Service*>(first_service_);
>}
>
>template <typename Service>
>Service& service_registry::use_service()
>{
> boost::asio::io_service::service::key key;
> init_key(key, Service::id);
> factory_type factory = &service_registry::create<Service>;
> return *static_cast<Service*>(do_use_service(key, factory));
>}
>
>template <typename Service>
>void service_registry::add_service(Service* new_service)
>{
> boost::asio::io_service::service::key key;
> init_key(key, Service::id);
> return do_add_service(key, new_service);
>}
>
>template <typename Service>
>bool service_registry::has_service() const
>{
> boost::asio::io_service::service::key key;
> init_key(key, Service::id);
> return do_has_service(key);
>}
>
>
>template <typename Service>
>void service_registry::init_key(boost::asio::io_service::service::key& key,
> const boost::asio::detail::service_id<Service>& )
>{
> key.type_info_ = &typeid(typeid_wrapper<Service>);
> key.id_ = 0;
>}
>
>
>template <typename Service>
>boost::asio::io_service::service* service_registry::create(
> boost::asio::io_service& owner)
>{
> return new Service(owner);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 89 "/usr/include/boost/asio/detail/impl/service_registry.hpp" 2 3 4
># 154 "/usr/include/boost/asio/detail/service_registry.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/service_registry.ipp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/service_registry.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/service_registry.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/impl/service_registry.ipp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/impl/service_registry.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>service_registry::~service_registry()
>{
>
>
>
> boost::asio::io_service::service* service = first_service_;
> while (service)
> {
> service->shutdown_service();
> service = service->next_;
> }
>
>
> while (first_service_)
> {
> boost::asio::io_service::service* next_service = first_service_->next_;
> destroy(first_service_);
> first_service_ = next_service;
> }
>}
>
>void service_registry::notify_fork(boost::asio::io_service::fork_event fork_ev)
>{
>
>
>
> std::vector<boost::asio::io_service::service*> services;
> {
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
> boost::asio::io_service::service* service = first_service_;
> while (service)
> {
> services.push_back(service);
> service = service->next_;
> }
> }
>
>
>
>
>
> std::size_t num_services = services.size();
> if (fork_ev == boost::asio::io_service::fork_prepare)
> for (std::size_t i = 0; i < num_services; ++i)
> services[i]->fork_service(fork_ev);
> else
> for (std::size_t i = num_services; i > 0; --i)
> services[i - 1]->fork_service(fork_ev);
>}
>
>void service_registry::init_key(boost::asio::io_service::service::key& key,
> const boost::asio::io_service::id& id)
>{
> key.type_info_ = 0;
> key.id_ = &id;
>}
>
>bool service_registry::keys_match(
> const boost::asio::io_service::service::key& key1,
> const boost::asio::io_service::service::key& key2)
>{
> if (key1.id_ && key2.id_)
> if (key1.id_ == key2.id_)
> return true;
> if (key1.type_info_ && key2.type_info_)
> if (*key1.type_info_ == *key2.type_info_)
> return true;
> return false;
>}
>
>void service_registry::destroy(boost::asio::io_service::service* service)
>{
> delete service;
>}
>
>boost::asio::io_service::service* service_registry::do_use_service(
> const boost::asio::io_service::service::key& key,
> factory_type factory)
>{
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
>
>
> boost::asio::io_service::service* service = first_service_;
> while (service)
> {
> if (keys_match(service->key_, key))
> return service;
> service = service->next_;
> }
>
>
>
>
> lock.unlock();
> auto_service_ptr new_service = { factory(owner_) };
> new_service.ptr_->key_ = key;
> lock.lock();
>
>
>
> service = first_service_;
> while (service)
> {
> if (keys_match(service->key_, key))
> return service;
> service = service->next_;
> }
>
>
> new_service.ptr_->next_ = first_service_;
> first_service_ = new_service.ptr_;
> new_service.ptr_ = 0;
> return first_service_;
>}
>
>void service_registry::do_add_service(
> const boost::asio::io_service::service::key& key,
> boost::asio::io_service::service* new_service)
>{
> if (&owner_ != &new_service->get_io_service())
> boost::asio::detail::throw_exception(invalid_service_owner());
>
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
>
>
> boost::asio::io_service::service* service = first_service_;
> while (service)
> {
> if (keys_match(service->key_, key))
> boost::asio::detail::throw_exception(service_already_exists());
> service = service->next_;
> }
>
>
> new_service->key_ = key;
> new_service->next_ = first_service_;
> first_service_ = new_service;
>}
>
>bool service_registry::do_has_service(
> const boost::asio::io_service::service::key& key) const
>{
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
>
> boost::asio::io_service::service* service = first_service_;
> while (service)
> {
> if (keys_match(service->key_, key))
> return true;
> service = service->next_;
> }
>
> return false;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 189 "/usr/include/boost/asio/detail/impl/service_registry.ipp" 2 3 4
># 156 "/usr/include/boost/asio/detail/service_registry.hpp" 2 3 4
># 20 "/usr/include/boost/asio/impl/io_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/impl/io_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>template <typename Service>
>inline Service& use_service(io_service& ios)
>{
>
> (void)static_cast<io_service::service*>(static_cast<Service*>(0));
> (void)static_cast<const io_service::id*>(&Service::id);
>
> return ios.service_registry_->template use_service<Service>();
>}
>
>template <>
>inline detail::io_service_impl& use_service<detail::io_service_impl>(
> io_service& ios)
>{
> return ios.impl_;
>}
>
>template <typename Service>
>inline void add_service(io_service& ios, Service* svc)
>{
>
> (void)static_cast<io_service::service*>(static_cast<Service*>(0));
> (void)static_cast<const io_service::id*>(&Service::id);
>
> ios.service_registry_->template add_service<Service>(svc);
>}
>
>template <typename Service>
>inline bool has_service(io_service& ios)
>{
>
> (void)static_cast<io_service::service*>(static_cast<Service*>(0));
> (void)static_cast<const io_service::id*>(&Service::id);
>
> return ios.service_registry_->template has_service<Service>();
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/impl/io_service.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/task_io_service.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/task_io_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/atomic_count.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/atomic_count.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/atomic" 1 3 4
># 35 "/usr/include/c++/4.8.2/atomic" 3 4
> 
># 36 "/usr/include/c++/4.8.2/atomic" 3
>
>
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/atomic_base.h" 1 3
># 33 "/usr/include/c++/4.8.2/bits/atomic_base.h" 3
> 
># 34 "/usr/include/c++/4.8.2/bits/atomic_base.h" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stdbool.h" 1 3 4
># 37 "/usr/include/c++/4.8.2/bits/atomic_base.h" 2 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 52 "/usr/include/c++/4.8.2/bits/atomic_base.h" 3
> typedef enum memory_order
> {
> memory_order_relaxed,
> memory_order_consume,
> memory_order_acquire,
> memory_order_release,
> memory_order_acq_rel,
> memory_order_seq_cst
> } memory_order;
>
> enum __memory_order_modifier
> {
> __memory_order_mask = 0x0ffff,
> __memory_order_modifier_mask = 0xffff0000,
> __memory_order_hle_acquire = 0x10000,
> __memory_order_hle_release = 0x20000
> };
>
> constexpr memory_order
> operator|(memory_order __m, __memory_order_modifier __mod)
> {
> return memory_order(__m | int(__mod));
> }
>
> constexpr memory_order
> operator&(memory_order __m, __memory_order_modifier __mod)
> {
> return memory_order(__m & int(__mod));
> }
>
>
> constexpr memory_order
> __cmpexch_failure_order2(memory_order __m) noexcept
> {
> return __m == memory_order_acq_rel ? memory_order_acquire
> : __m == memory_order_release ? memory_order_relaxed : __m;
> }
>
> constexpr memory_order
> __cmpexch_failure_order(memory_order __m) noexcept
> {
> return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask)
> | (__m & __memory_order_modifier_mask));
> }
>
> inline void
> atomic_thread_fence(memory_order __m) noexcept
> { __atomic_thread_fence(__m); }
>
> inline void
> atomic_signal_fence(memory_order __m) noexcept
> { __atomic_signal_fence(__m); }
>
>
> template<typename _Tp>
> inline _Tp
> kill_dependency(_Tp __y) noexcept
> {
> _Tp __ret(__y);
> return __ret;
> }
>
>
>
> template<typename _IntTp>
> struct __atomic_base;
>
>
> typedef __atomic_base<char> atomic_char;
>
>
> typedef __atomic_base<signed char> atomic_schar;
>
>
> typedef __atomic_base<unsigned char> atomic_uchar;
>
>
> typedef __atomic_base<short> atomic_short;
>
>
> typedef __atomic_base<unsigned short> atomic_ushort;
>
>
> typedef __atomic_base<int> atomic_int;
>
>
> typedef __atomic_base<unsigned int> atomic_uint;
>
>
> typedef __atomic_base<long> atomic_long;
>
>
> typedef __atomic_base<unsigned long> atomic_ulong;
>
>
> typedef __atomic_base<long long> atomic_llong;
>
>
> typedef __atomic_base<unsigned long long> atomic_ullong;
>
>
> typedef __atomic_base<wchar_t> atomic_wchar_t;
>
>
> typedef __atomic_base<char16_t> atomic_char16_t;
>
>
> typedef __atomic_base<char32_t> atomic_char32_t;
>
>
> typedef __atomic_base<char32_t> atomic_char32_t;
>
>
>
> typedef __atomic_base<int_least8_t> atomic_int_least8_t;
>
>
> typedef __atomic_base<uint_least8_t> atomic_uint_least8_t;
>
>
> typedef __atomic_base<int_least16_t> atomic_int_least16_t;
>
>
> typedef __atomic_base<uint_least16_t> atomic_uint_least16_t;
>
>
> typedef __atomic_base<int_least32_t> atomic_int_least32_t;
>
>
> typedef __atomic_base<uint_least32_t> atomic_uint_least32_t;
>
>
> typedef __atomic_base<int_least64_t> atomic_int_least64_t;
>
>
> typedef __atomic_base<uint_least64_t> atomic_uint_least64_t;
>
>
>
> typedef __atomic_base<int_fast8_t> atomic_int_fast8_t;
>
>
> typedef __atomic_base<uint_fast8_t> atomic_uint_fast8_t;
>
>
> typedef __atomic_base<int_fast16_t> atomic_int_fast16_t;
>
>
> typedef __atomic_base<uint_fast16_t> atomic_uint_fast16_t;
>
>
> typedef __atomic_base<int_fast32_t> atomic_int_fast32_t;
>
>
> typedef __atomic_base<uint_fast32_t> atomic_uint_fast32_t;
>
>
> typedef __atomic_base<int_fast64_t> atomic_int_fast64_t;
>
>
> typedef __atomic_base<uint_fast64_t> atomic_uint_fast64_t;
>
>
>
> typedef __atomic_base<intptr_t> atomic_intptr_t;
>
>
> typedef __atomic_base<uintptr_t> atomic_uintptr_t;
>
>
> typedef __atomic_base<size_t> atomic_size_t;
>
>
> typedef __atomic_base<intmax_t> atomic_intmax_t;
>
>
> typedef __atomic_base<uintmax_t> atomic_uintmax_t;
>
>
> typedef __atomic_base<ptrdiff_t> atomic_ptrdiff_t;
>
>
>
>
> template<typename _Tp>
> struct atomic;
>
> template<typename _Tp>
> struct atomic<_Tp*>;
>
>
>
> typedef bool __atomic_flag_data_type;
># 259 "/usr/include/c++/4.8.2/bits/atomic_base.h" 3
> extern "C" {
>
> struct __atomic_flag_base
> {
> __atomic_flag_data_type _M_i;
> };
>
> }
>
>
>
>
> struct atomic_flag : public __atomic_flag_base
> {
> atomic_flag() noexcept = default;
> ~atomic_flag() noexcept = default;
> atomic_flag(const atomic_flag&) = delete;
> atomic_flag& operator=(const atomic_flag&) = delete;
> atomic_flag& operator=(const atomic_flag&) volatile = delete;
>
>
> constexpr atomic_flag(bool __i) noexcept
> : __atomic_flag_base{ _S_init(__i) }
> { }
>
> bool
> test_and_set(memory_order __m = memory_order_seq_cst) noexcept
> {
> return __atomic_test_and_set (&_M_i, __m);
> }
>
> bool
> test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> return __atomic_test_and_set (&_M_i, __m);
> }
>
> void
> clear(memory_order __m = memory_order_seq_cst) noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
> ;
>
> __atomic_clear (&_M_i, __m);
> }
>
> void
> clear(memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
> ;
>
> __atomic_clear (&_M_i, __m);
> }
>
> private:
> static constexpr __atomic_flag_data_type
> _S_init(bool __i)
> { return __i ? 1 : 0; }
> };
># 348 "/usr/include/c++/4.8.2/bits/atomic_base.h" 3
> template<typename _ITp>
> struct __atomic_base
> {
> private:
> typedef _ITp __int_type;
>
> __int_type _M_i;
>
> public:
> __atomic_base() noexcept = default;
> ~__atomic_base() noexcept = default;
> __atomic_base(const __atomic_base&) = delete;
> __atomic_base& operator=(const __atomic_base&) = delete;
> __atomic_base& operator=(const __atomic_base&) volatile = delete;
>
>
> constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }
>
> operator __int_type() const noexcept
> { return load(); }
>
> operator __int_type() const volatile noexcept
> { return load(); }
>
> __int_type
> operator=(__int_type __i) noexcept
> {
> store(__i);
> return __i;
> }
>
> __int_type
> operator=(__int_type __i) volatile noexcept
> {
> store(__i);
> return __i;
> }
>
> __int_type
> operator++(int) noexcept
> { return fetch_add(1); }
>
> __int_type
> operator++(int) volatile noexcept
> { return fetch_add(1); }
>
> __int_type
> operator--(int) noexcept
> { return fetch_sub(1); }
>
> __int_type
> operator--(int) volatile noexcept
> { return fetch_sub(1); }
>
> __int_type
> operator++() noexcept
> { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
>
> __int_type
> operator++() volatile noexcept
> { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
>
> __int_type
> operator--() noexcept
> { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
>
> __int_type
> operator--() volatile noexcept
> { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
>
> __int_type
> operator+=(__int_type __i) noexcept
> { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator+=(__int_type __i) volatile noexcept
> { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator-=(__int_type __i) noexcept
> { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator-=(__int_type __i) volatile noexcept
> { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator&=(__int_type __i) noexcept
> { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator&=(__int_type __i) volatile noexcept
> { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator|=(__int_type __i) noexcept
> { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator|=(__int_type __i) volatile noexcept
> { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator^=(__int_type __i) noexcept
> { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator^=(__int_type __i) volatile noexcept
> { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> bool
> is_lock_free() const noexcept
> { return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
>
> bool
> is_lock_free() const volatile noexcept
> { return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
>
> void
> store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
> ;
>
> __atomic_store_n(&_M_i, __i, __m);
> }
>
> void
> store(__int_type __i,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
> ;
>
> __atomic_store_n(&_M_i, __i, __m);
> }
>
> __int_type
> load(memory_order __m = memory_order_seq_cst) const noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
>
> return __atomic_load_n(&_M_i, __m);
> }
>
> __int_type
> load(memory_order __m = memory_order_seq_cst) const volatile noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
>
> return __atomic_load_n(&_M_i, __m);
> }
>
> __int_type
> exchange(__int_type __i,
> memory_order __m = memory_order_seq_cst) noexcept
> {
> return __atomic_exchange_n(&_M_i, __i, __m);
> }
>
>
> __int_type
> exchange(__int_type __i,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> return __atomic_exchange_n(&_M_i, __i, __m);
> }
>
> bool
> compare_exchange_weak(__int_type& __i1, __int_type __i2,
> memory_order __m1, memory_order __m2) noexcept
> {
> memory_order __b2 = __m2 & __memory_order_mask;
> memory_order __b1 = __m1 & __memory_order_mask;
> ;
> ;
> ;
>
> return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
> }
>
> bool
> compare_exchange_weak(__int_type& __i1, __int_type __i2,
> memory_order __m1,
> memory_order __m2) volatile noexcept
> {
> memory_order __b2 = __m2 & __memory_order_mask;
> memory_order __b1 = __m1 & __memory_order_mask;
> ;
> ;
> ;
>
> return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
> }
>
> bool
> compare_exchange_weak(__int_type& __i1, __int_type __i2,
> memory_order __m = memory_order_seq_cst) noexcept
> {
> return compare_exchange_weak(__i1, __i2, __m,
> __cmpexch_failure_order(__m));
> }
>
> bool
> compare_exchange_weak(__int_type& __i1, __int_type __i2,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> return compare_exchange_weak(__i1, __i2, __m,
> __cmpexch_failure_order(__m));
> }
>
> bool
> compare_exchange_strong(__int_type& __i1, __int_type __i2,
> memory_order __m1, memory_order __m2) noexcept
> {
> memory_order __b2 = __m2 & __memory_order_mask;
> memory_order __b1 = __m1 & __memory_order_mask;
> ;
> ;
> ;
>
> return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
> }
>
> bool
> compare_exchange_strong(__int_type& __i1, __int_type __i2,
> memory_order __m1,
> memory_order __m2) volatile noexcept
> {
> memory_order __b2 = __m2 & __memory_order_mask;
> memory_order __b1 = __m1 & __memory_order_mask;
>
> ;
> ;
> ;
>
> return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
> }
>
> bool
> compare_exchange_strong(__int_type& __i1, __int_type __i2,
> memory_order __m = memory_order_seq_cst) noexcept
> {
> return compare_exchange_strong(__i1, __i2, __m,
> __cmpexch_failure_order(__m));
> }
>
> bool
> compare_exchange_strong(__int_type& __i1, __int_type __i2,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> return compare_exchange_strong(__i1, __i2, __m,
> __cmpexch_failure_order(__m));
> }
>
> __int_type
> fetch_add(__int_type __i,
> memory_order __m = memory_order_seq_cst) noexcept
> { return __atomic_fetch_add(&_M_i, __i, __m); }
>
> __int_type
> fetch_add(__int_type __i,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return __atomic_fetch_add(&_M_i, __i, __m); }
>
> __int_type
> fetch_sub(__int_type __i,
> memory_order __m = memory_order_seq_cst) noexcept
> { return __atomic_fetch_sub(&_M_i, __i, __m); }
>
> __int_type
> fetch_sub(__int_type __i,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return __atomic_fetch_sub(&_M_i, __i, __m); }
>
> __int_type
> fetch_and(__int_type __i,
> memory_order __m = memory_order_seq_cst) noexcept
> { return __atomic_fetch_and(&_M_i, __i, __m); }
>
> __int_type
> fetch_and(__int_type __i,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return __atomic_fetch_and(&_M_i, __i, __m); }
>
> __int_type
> fetch_or(__int_type __i,
> memory_order __m = memory_order_seq_cst) noexcept
> { return __atomic_fetch_or(&_M_i, __i, __m); }
>
> __int_type
> fetch_or(__int_type __i,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return __atomic_fetch_or(&_M_i, __i, __m); }
>
> __int_type
> fetch_xor(__int_type __i,
> memory_order __m = memory_order_seq_cst) noexcept
> { return __atomic_fetch_xor(&_M_i, __i, __m); }
>
> __int_type
> fetch_xor(__int_type __i,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return __atomic_fetch_xor(&_M_i, __i, __m); }
> };
>
>
>
> template<typename _PTp>
> struct __atomic_base<_PTp*>
> {
> private:
> typedef _PTp* __pointer_type;
>
> __pointer_type _M_p;
>
>
> constexpr ptrdiff_t
> _M_type_size(ptrdiff_t __d) { return __d * sizeof(_PTp); }
>
> constexpr ptrdiff_t
> _M_type_size(ptrdiff_t __d) volatile { return __d * sizeof(_PTp); }
>
> public:
> __atomic_base() noexcept = default;
> ~__atomic_base() noexcept = default;
> __atomic_base(const __atomic_base&) = delete;
> __atomic_base& operator=(const __atomic_base&) = delete;
> __atomic_base& operator=(const __atomic_base&) volatile = delete;
>
>
> constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { }
>
> operator __pointer_type() const noexcept
> { return load(); }
>
> operator __pointer_type() const volatile noexcept
> { return load(); }
>
> __pointer_type
> operator=(__pointer_type __p) noexcept
> {
> store(__p);
> return __p;
> }
>
> __pointer_type
> operator=(__pointer_type __p) volatile noexcept
> {
> store(__p);
> return __p;
> }
>
> __pointer_type
> operator++(int) noexcept
> { return fetch_add(1); }
>
> __pointer_type
> operator++(int) volatile noexcept
> { return fetch_add(1); }
>
> __pointer_type
> operator--(int) noexcept
> { return fetch_sub(1); }
>
> __pointer_type
> operator--(int) volatile noexcept
> { return fetch_sub(1); }
>
> __pointer_type
> operator++() noexcept
> { return __atomic_add_fetch(&_M_p, _M_type_size(1),
> memory_order_seq_cst); }
>
> __pointer_type
> operator++() volatile noexcept
> { return __atomic_add_fetch(&_M_p, _M_type_size(1),
> memory_order_seq_cst); }
>
> __pointer_type
> operator--() noexcept
> { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
> memory_order_seq_cst); }
>
> __pointer_type
> operator--() volatile noexcept
> { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
> memory_order_seq_cst); }
>
> __pointer_type
> operator+=(ptrdiff_t __d) noexcept
> { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
> memory_order_seq_cst); }
>
> __pointer_type
> operator+=(ptrdiff_t __d) volatile noexcept
> { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
> memory_order_seq_cst); }
>
> __pointer_type
> operator-=(ptrdiff_t __d) noexcept
> { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
> memory_order_seq_cst); }
>
> __pointer_type
> operator-=(ptrdiff_t __d) volatile noexcept
> { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
> memory_order_seq_cst); }
>
> bool
> is_lock_free() const noexcept
> { return __atomic_is_lock_free(_M_type_size(1), nullptr); }
>
> bool
> is_lock_free() const volatile noexcept
> { return __atomic_is_lock_free(_M_type_size(1), nullptr); }
>
> void
> store(__pointer_type __p,
> memory_order __m = memory_order_seq_cst) noexcept
> {
> memory_order __b = __m & __memory_order_mask;
>
> ;
> ;
> ;
>
> __atomic_store_n(&_M_p, __p, __m);
> }
>
> void
> store(__pointer_type __p,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
> ;
>
> __atomic_store_n(&_M_p, __p, __m);
> }
>
> __pointer_type
> load(memory_order __m = memory_order_seq_cst) const noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
>
> return __atomic_load_n(&_M_p, __m);
> }
>
> __pointer_type
> load(memory_order __m = memory_order_seq_cst) const volatile noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
>
> return __atomic_load_n(&_M_p, __m);
> }
>
> __pointer_type
> exchange(__pointer_type __p,
> memory_order __m = memory_order_seq_cst) noexcept
> {
> return __atomic_exchange_n(&_M_p, __p, __m);
> }
>
>
> __pointer_type
> exchange(__pointer_type __p,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> return __atomic_exchange_n(&_M_p, __p, __m);
> }
>
> bool
> compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m1,
> memory_order __m2) noexcept
> {
> memory_order __b2 = __m2 & __memory_order_mask;
> memory_order __b1 = __m1 & __memory_order_mask;
> ;
> ;
> ;
>
> return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
> }
>
> bool
> compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m1,
> memory_order __m2) volatile noexcept
> {
> memory_order __b2 = __m2 & __memory_order_mask;
> memory_order __b1 = __m1 & __memory_order_mask;
>
> ;
> ;
> ;
>
> return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
> }
>
> __pointer_type
> fetch_add(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) noexcept
> { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
>
> __pointer_type
> fetch_add(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
>
> __pointer_type
> fetch_sub(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) noexcept
> { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
>
> __pointer_type
> fetch_sub(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
> };
>
>
>
>
>}
># 42 "/usr/include/c++/4.8.2/atomic" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 54 "/usr/include/c++/4.8.2/atomic" 3
> struct atomic_bool
> {
> private:
> __atomic_base<bool> _M_base;
>
> public:
> atomic_bool() noexcept = default;
> ~atomic_bool() noexcept = default;
> atomic_bool(const atomic_bool&) = delete;
> atomic_bool& operator=(const atomic_bool&) = delete;
> atomic_bool& operator=(const atomic_bool&) volatile = delete;
>
> constexpr atomic_bool(bool __i) noexcept : _M_base(__i) { }
>
> bool
> operator=(bool __i) noexcept
> { return _M_base.operator=(__i); }
>
> bool
> operator=(bool __i) volatile noexcept
> { return _M_base.operator=(__i); }
>
> operator bool() const noexcept
> { return _M_base.load(); }
>
> operator bool() const volatile noexcept
> { return _M_base.load(); }
>
> bool
> is_lock_free() const noexcept { return _M_base.is_lock_free(); }
>
> bool
> is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
>
> void
> store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
> { _M_base.store(__i, __m); }
>
> void
> store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
> { _M_base.store(__i, __m); }
>
> bool
> load(memory_order __m = memory_order_seq_cst) const noexcept
> { return _M_base.load(__m); }
>
> bool
> load(memory_order __m = memory_order_seq_cst) const volatile noexcept
> { return _M_base.load(__m); }
>
> bool
> exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
> { return _M_base.exchange(__i, __m); }
>
> bool
> exchange(bool __i,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return _M_base.exchange(__i, __m); }
>
> bool
> compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
> memory_order __m2) noexcept
> { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
>
> bool
> compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
> memory_order __m2) volatile noexcept
> { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
>
> bool
> compare_exchange_weak(bool& __i1, bool __i2,
> memory_order __m = memory_order_seq_cst) noexcept
> { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
>
> bool
> compare_exchange_weak(bool& __i1, bool __i2,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
>
> bool
> compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
> memory_order __m2) noexcept
> { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
>
> bool
> compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
> memory_order __m2) volatile noexcept
> { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
>
> bool
> compare_exchange_strong(bool& __i1, bool __i2,
> memory_order __m = memory_order_seq_cst) noexcept
> { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
>
> bool
> compare_exchange_strong(bool& __i1, bool __i2,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
> };
>
>
>
>
>
>
>
> template<typename _Tp>
> struct atomic
> {
> private:
> _Tp _M_i;
>
> public:
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
>
> operator _Tp() const noexcept
> { return load(); }
>
> operator _Tp() const volatile noexcept
> { return load(); }
>
> _Tp
> operator=(_Tp __i) noexcept
> { store(__i); return __i; }
>
> _Tp
> operator=(_Tp __i) volatile noexcept
> { store(__i); return __i; }
>
> bool
> is_lock_free() const noexcept
> { return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
>
> bool
> is_lock_free() const volatile noexcept
> { return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
>
> void
> store(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept
> { __atomic_store(&_M_i, &__i, _m); }
>
> void
> store(_Tp __i, memory_order _m = memory_order_seq_cst) volatile noexcept
> { __atomic_store(&_M_i, &__i, _m); }
>
> _Tp
> load(memory_order _m = memory_order_seq_cst) const noexcept
> {
> _Tp tmp;
> __atomic_load(&_M_i, &tmp, _m);
> return tmp;
> }
>
> _Tp
> load(memory_order _m = memory_order_seq_cst) const volatile noexcept
> {
> _Tp tmp;
> __atomic_load(&_M_i, &tmp, _m);
> return tmp;
> }
>
> _Tp
> exchange(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept
> {
> _Tp tmp;
> __atomic_exchange(&_M_i, &__i, &tmp, _m);
> return tmp;
> }
>
> _Tp
> exchange(_Tp __i,
> memory_order _m = memory_order_seq_cst) volatile noexcept
> {
> _Tp tmp;
> __atomic_exchange(&_M_i, &__i, &tmp, _m);
> return tmp;
> }
>
> bool
> compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
> memory_order __f) noexcept
> {
> return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
> }
>
> bool
> compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
> memory_order __f) volatile noexcept
> {
> return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
> }
>
> bool
> compare_exchange_weak(_Tp& __e, _Tp __i,
> memory_order __m = memory_order_seq_cst) noexcept
> { return compare_exchange_weak(__e, __i, __m, __m); }
>
> bool
> compare_exchange_weak(_Tp& __e, _Tp __i,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return compare_exchange_weak(__e, __i, __m, __m); }
>
> bool
> compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
> memory_order __f) noexcept
> {
> return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
> }
>
> bool
> compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
> memory_order __f) volatile noexcept
> {
> return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
> }
>
> bool
> compare_exchange_strong(_Tp& __e, _Tp __i,
> memory_order __m = memory_order_seq_cst) noexcept
> { return compare_exchange_strong(__e, __i, __m, __m); }
>
> bool
> compare_exchange_strong(_Tp& __e, _Tp __i,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return compare_exchange_strong(__e, __i, __m, __m); }
> };
>
>
>
> template<typename _Tp>
> struct atomic<_Tp*>
> {
> typedef _Tp* __pointer_type;
> typedef __atomic_base<_Tp*> __base_type;
> __base_type _M_b;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
>
> operator __pointer_type() const noexcept
> { return __pointer_type(_M_b); }
>
> operator __pointer_type() const volatile noexcept
> { return __pointer_type(_M_b); }
>
> __pointer_type
> operator=(__pointer_type __p) noexcept
> { return _M_b.operator=(__p); }
>
> __pointer_type
> operator=(__pointer_type __p) volatile noexcept
> { return _M_b.operator=(__p); }
>
> __pointer_type
> operator++(int) noexcept
> { return _M_b++; }
>
> __pointer_type
> operator++(int) volatile noexcept
> { return _M_b++; }
>
> __pointer_type
> operator--(int) noexcept
> { return _M_b--; }
>
> __pointer_type
> operator--(int) volatile noexcept
> { return _M_b--; }
>
> __pointer_type
> operator++() noexcept
> { return ++_M_b; }
>
> __pointer_type
> operator++() volatile noexcept
> { return ++_M_b; }
>
> __pointer_type
> operator--() noexcept
> { return --_M_b; }
>
> __pointer_type
> operator--() volatile noexcept
> { return --_M_b; }
>
> __pointer_type
> operator+=(ptrdiff_t __d) noexcept
> { return _M_b.operator+=(__d); }
>
> __pointer_type
> operator+=(ptrdiff_t __d) volatile noexcept
> { return _M_b.operator+=(__d); }
>
> __pointer_type
> operator-=(ptrdiff_t __d) noexcept
> { return _M_b.operator-=(__d); }
>
> __pointer_type
> operator-=(ptrdiff_t __d) volatile noexcept
> { return _M_b.operator-=(__d); }
>
> bool
> is_lock_free() const noexcept
> { return _M_b.is_lock_free(); }
>
> bool
> is_lock_free() const volatile noexcept
> { return _M_b.is_lock_free(); }
>
> void
> store(__pointer_type __p,
> memory_order __m = memory_order_seq_cst) noexcept
> { return _M_b.store(__p, __m); }
>
> void
> store(__pointer_type __p,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return _M_b.store(__p, __m); }
>
> __pointer_type
> load(memory_order __m = memory_order_seq_cst) const noexcept
> { return _M_b.load(__m); }
>
> __pointer_type
> load(memory_order __m = memory_order_seq_cst) const volatile noexcept
> { return _M_b.load(__m); }
>
> __pointer_type
> exchange(__pointer_type __p,
> memory_order __m = memory_order_seq_cst) noexcept
> { return _M_b.exchange(__p, __m); }
>
> __pointer_type
> exchange(__pointer_type __p,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return _M_b.exchange(__p, __m); }
>
> bool
> compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m1, memory_order __m2) noexcept
> { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
>
> bool
> compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m1,
> memory_order __m2) volatile noexcept
> { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
>
> bool
> compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m = memory_order_seq_cst) noexcept
> {
> return compare_exchange_weak(__p1, __p2, __m,
> __cmpexch_failure_order(__m));
> }
>
> bool
> compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> return compare_exchange_weak(__p1, __p2, __m,
> __cmpexch_failure_order(__m));
> }
>
> bool
> compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m1, memory_order __m2) noexcept
> { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
>
> bool
> compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m1,
> memory_order __m2) volatile noexcept
> { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
>
> bool
> compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m = memory_order_seq_cst) noexcept
> {
> return _M_b.compare_exchange_strong(__p1, __p2, __m,
> __cmpexch_failure_order(__m));
> }
>
> bool
> compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> return _M_b.compare_exchange_strong(__p1, __p2, __m,
> __cmpexch_failure_order(__m));
> }
>
> __pointer_type
> fetch_add(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) noexcept
> { return _M_b.fetch_add(__d, __m); }
>
> __pointer_type
> fetch_add(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return _M_b.fetch_add(__d, __m); }
>
> __pointer_type
> fetch_sub(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) noexcept
> { return _M_b.fetch_sub(__d, __m); }
>
> __pointer_type
> fetch_sub(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return _M_b.fetch_sub(__d, __m); }
> };
>
>
>
> template<>
> struct atomic<bool> : public atomic_bool
> {
> typedef bool __integral_type;
> typedef atomic_bool __base_type;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
> };
>
>
> template<>
> struct atomic<char> : public atomic_char
> {
> typedef char __integral_type;
> typedef atomic_char __base_type;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
> };
>
>
> template<>
> struct atomic<signed char> : public atomic_schar
> {
> typedef signed char __integral_type;
> typedef atomic_schar __base_type;
>
> atomic() noexcept= default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
> };
>
>
> template<>
> struct atomic<unsigned char> : public atomic_uchar
> {
> typedef unsigned char __integral_type;
> typedef atomic_uchar __base_type;
>
> atomic() noexcept= default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
> };
>
>
> template<>
> struct atomic<short> : public atomic_short
> {
> typedef short __integral_type;
> typedef atomic_short __base_type;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
> };
>
>
> template<>
> struct atomic<unsigned short> : public atomic_ushort
> {
> typedef unsigned short __integral_type;
> typedef atomic_ushort __base_type;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
> };
>
>
> template<>
> struct atomic<int> : atomic_int
> {
> typedef int __integral_type;
> typedef atomic_int __base_type;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
> };
>
>
> template<>
> struct atomic<unsigned int> : public atomic_uint
> {
> typedef unsigned int __integral_type;
> typedef atomic_uint __base_type;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
> };
>
>
> template<>
> struct atomic<long> : public atomic_long
> {
> typedef long __integral_type;
> typedef atomic_long __base_type;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
> };
>
>
> template<>
> struct atomic<unsigned long> : public atomic_ulong
> {
> typedef unsigned long __integral_type;
> typedef atomic_ulong __base_type;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
> };
>
>
> template<>
> struct atomic<long long> : public atomic_llong
> {
> typedef long long __integral_type;
> typedef atomic_llong __base_type;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
> };
>
>
> template<>
> struct atomic<unsigned long long> : public atomic_ullong
> {
> typedef unsigned long long __integral_type;
> typedef atomic_ullong __base_type;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
> };
>
>
> template<>
> struct atomic<wchar_t> : public atomic_wchar_t
> {
> typedef wchar_t __integral_type;
> typedef atomic_wchar_t __base_type;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
> };
>
>
> template<>
> struct atomic<char16_t> : public atomic_char16_t
> {
> typedef char16_t __integral_type;
> typedef atomic_char16_t __base_type;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
> };
>
>
> template<>
> struct atomic<char32_t> : public atomic_char32_t
> {
> typedef char32_t __integral_type;
> typedef atomic_char32_t __base_type;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
> };
>
>
>
> inline bool
> atomic_flag_test_and_set_explicit(atomic_flag* __a,
> memory_order __m) noexcept
> { return __a->test_and_set(__m); }
>
> inline bool
> atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
> memory_order __m) noexcept
> { return __a->test_and_set(__m); }
>
> inline void
> atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
> { __a->clear(__m); }
>
> inline void
> atomic_flag_clear_explicit(volatile atomic_flag* __a,
> memory_order __m) noexcept
> { __a->clear(__m); }
>
> inline bool
> atomic_flag_test_and_set(atomic_flag* __a) noexcept
> { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
>
> inline bool
> atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
> { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
>
> inline void
> atomic_flag_clear(atomic_flag* __a) noexcept
> { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
>
> inline void
> atomic_flag_clear(volatile atomic_flag* __a) noexcept
> { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
>
>
>
> template<typename _ITp>
> inline bool
> atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
> { return __a->is_lock_free(); }
>
> template<typename _ITp>
> inline bool
> atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
> { return __a->is_lock_free(); }
>
> template<typename _ITp>
> inline void
> atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept;
>
> template<typename _ITp>
> inline void
> atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept;
>
> template<typename _ITp>
> inline void
> atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { __a->store(__i, __m); }
>
> template<typename _ITp>
> inline void
> atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { __a->store(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
> { return __a->load(__m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_load_explicit(const volatile atomic<_ITp>* __a,
> memory_order __m) noexcept
> { return __a->load(__m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->exchange(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->exchange(__i, __m); }
>
> template<typename _ITp>
> inline bool
> atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
> _ITp* __i1, _ITp __i2,
> memory_order __m1,
> memory_order __m2) noexcept
> { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
>
> template<typename _ITp>
> inline bool
> atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
> _ITp* __i1, _ITp __i2,
> memory_order __m1,
> memory_order __m2) noexcept
> { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
>
> template<typename _ITp>
> inline bool
> atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
> _ITp* __i1, _ITp __i2,
> memory_order __m1,
> memory_order __m2) noexcept
> { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
>
> template<typename _ITp>
> inline bool
> atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
> _ITp* __i1, _ITp __i2,
> memory_order __m1,
> memory_order __m2) noexcept
> { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
>
>
> template<typename _ITp>
> inline void
> atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
> { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline void
> atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept
> { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_load(const atomic<_ITp>* __a) noexcept
> { return atomic_load_explicit(__a, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_load(const volatile atomic<_ITp>* __a) noexcept
> { return atomic_load_explicit(__a, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
> { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept
> { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline bool
> atomic_compare_exchange_weak(atomic<_ITp>* __a,
> _ITp* __i1, _ITp __i2) noexcept
> {
> return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
> memory_order_seq_cst,
> memory_order_seq_cst);
> }
>
> template<typename _ITp>
> inline bool
> atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
> _ITp* __i1, _ITp __i2) noexcept
> {
> return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
> memory_order_seq_cst,
> memory_order_seq_cst);
> }
>
> template<typename _ITp>
> inline bool
> atomic_compare_exchange_strong(atomic<_ITp>* __a,
> _ITp* __i1, _ITp __i2) noexcept
> {
> return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
> memory_order_seq_cst,
> memory_order_seq_cst);
> }
>
> template<typename _ITp>
> inline bool
> atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
> _ITp* __i1, _ITp __i2) noexcept
> {
> return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
> memory_order_seq_cst,
> memory_order_seq_cst);
> }
>
>
>
>
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->fetch_add(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->fetch_add(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->fetch_sub(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->fetch_sub(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->fetch_and(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->fetch_and(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->fetch_or(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->fetch_or(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->fetch_xor(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->fetch_xor(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
> { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
> { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
> { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
> { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
> { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
> { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
> { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
> { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
> { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
> { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
>
>
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
> memory_order __m) noexcept
> { return __a->fetch_add(__d, __m); }
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d,
> memory_order __m) noexcept
> { return __a->fetch_add(__d, __m); }
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
> { return __a->fetch_add(__d); }
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
> { return __a->fetch_add(__d); }
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a,
> ptrdiff_t __d, memory_order __m) noexcept
> { return __a->fetch_sub(__d, __m); }
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
> memory_order __m) noexcept
> { return __a->fetch_sub(__d, __m); }
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
> { return __a->fetch_sub(__d); }
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
> { return __a->fetch_sub(__d); }
>
>
>
>}
># 24 "/usr/include/boost/asio/detail/atomic_count.hpp" 2 3 4
>
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>
>typedef std::atomic<long> atomic_count;
>inline void increment(atomic_count& a, long b) { a += b; }
>
>
>
>
>
>}
>}
>}
># 25 "/usr/include/boost/asio/detail/task_io_service.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/reactor_fwd.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/reactor_fwd.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/epoll_reactor_fwd.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/epoll_reactor_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>class epoll_reactor;
>
>}
>}
>}
># 24 "/usr/include/boost/asio/detail/reactor_fwd.hpp" 2 3 4
># 32 "/usr/include/boost/asio/detail/reactor_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>typedef epoll_reactor reactor;
># 48 "/usr/include/boost/asio/detail/reactor_fwd.hpp" 3 4
>}
>}
>}
># 29 "/usr/include/boost/asio/detail/task_io_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/task_io_service_operation.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/task_io_service_operation.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/handler_tracking.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/handler_tracking.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/detail/handler_tracking.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
># 151 "/usr/include/boost/asio/detail/handler_tracking.hpp" 3 4
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 156 "/usr/include/boost/asio/detail/handler_tracking.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/handler_tracking.ipp" 1 3 4
># 159 "/usr/include/boost/asio/detail/handler_tracking.hpp" 2 3 4
># 20 "/usr/include/boost/asio/detail/task_io_service_operation.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/task_io_service_operation.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>class task_io_service_operation
>{
>public:
> void complete(task_io_service& owner,
> const boost::system::error_code& ec, std::size_t bytes_transferred)
> {
> func_(&owner, this, ec, bytes_transferred);
> }
>
> void destroy()
> {
> func_(0, this, boost::system::error_code(), 0);
> }
>
>protected:
> typedef void (*func_type)(task_io_service*,
> task_io_service_operation*,
> const boost::system::error_code&, std::size_t);
>
> task_io_service_operation(func_type func)
> : next_(0),
> func_(func),
> task_result_(0)
> {
> }
>
>
> ~task_io_service_operation()
> {
> }
>
>private:
> friend class op_queue_access;
> task_io_service_operation* next_;
> func_type func_;
>protected:
> friend class task_io_service;
> unsigned int task_result_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 76 "/usr/include/boost/asio/detail/task_io_service_operation.hpp" 2 3 4
># 31 "/usr/include/boost/asio/detail/task_io_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 33 "/usr/include/boost/asio/detail/task_io_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class task_io_service
> : public boost::asio::detail::service_base<task_io_service>
>{
>public:
> typedef task_io_service_operation operation;
>
>
>
> inline task_io_service(boost::asio::io_service& io_service,
> std::size_t concurrency_hint = 0);
>
>
> inline void shutdown_service();
>
>
> inline void init_task();
>
>
> inline std::size_t run(boost::system::error_code& ec);
>
>
> inline std::size_t run_one(boost::system::error_code& ec);
>
>
> inline std::size_t poll(boost::system::error_code& ec);
>
>
> inline std::size_t poll_one(boost::system::error_code& ec);
>
>
> inline void stop();
>
>
> inline bool stopped() const;
>
>
> inline void reset();
>
>
> void work_started()
> {
> ++outstanding_work_;
> }
>
>
> void work_finished()
> {
> if (--outstanding_work_ == 0)
> stop();
> }
>
>
> bool can_dispatch()
> {
> return thread_call_stack::contains(this) != 0;
> }
>
>
> template <typename Handler>
> void dispatch(Handler& handler);
>
>
> template <typename Handler>
> void post(Handler& handler);
>
>
>
> inline void post_immediate_completion(
> operation* op, bool is_continuation);
>
>
>
> inline void post_deferred_completion(operation* op);
>
>
>
> inline void post_deferred_completions(op_queue<operation>& ops);
>
>
>
> inline void abandon_operations(op_queue<operation>& ops);
>
>private:
>
> typedef task_io_service_thread_info thread_info;
>
>
>
> inline void do_dispatch(operation* op);
>
>
> inline std::size_t do_run_one(mutex::scoped_lock& lock,
> thread_info& this_thread, const boost::system::error_code& ec);
>
>
> inline std::size_t do_poll_one(mutex::scoped_lock& lock,
> thread_info& this_thread, const boost::system::error_code& ec);
>
>
> inline void stop_all_threads(mutex::scoped_lock& lock);
>
>
>
>
> inline bool wake_one_idle_thread_and_unlock(
> mutex::scoped_lock& lock);
>
>
> inline void wake_one_thread_and_unlock(
> mutex::scoped_lock& lock);
>
>
> struct task_cleanup;
> friend struct task_cleanup;
>
>
> struct work_cleanup;
> friend struct work_cleanup;
>
>
> const bool one_thread_;
>
>
> mutable mutex mutex_;
>
>
> reactor* task_;
>
>
> struct task_operation : operation
> {
> task_operation() : operation(0) {}
> } task_operation_;
>
>
> bool task_interrupted_;
>
>
> atomic_count outstanding_work_;
>
>
> op_queue<operation> op_queue_;
>
>
> bool stopped_;
>
>
> bool shutdown_;
>
>
> typedef call_stack<task_io_service, thread_info> thread_call_stack;
>
>
> thread_info* first_idle_thread_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 199 "/usr/include/boost/asio/detail/task_io_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/task_io_service.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/impl/task_io_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/completion_handler.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/completion_handler.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/fenced_block.hpp" 1 3 4
># 33 "/usr/include/boost/asio/detail/fenced_block.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/gcc_x86_fenced_block.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/gcc_x86_fenced_block.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/gcc_x86_fenced_block.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class gcc_x86_fenced_block
> : private noncopyable
>{
>public:
> enum half_t { half };
> enum full_t { full };
>
>
> explicit gcc_x86_fenced_block(half_t)
> {
> }
>
>
> explicit gcc_x86_fenced_block(full_t)
> {
> lbarrier();
> }
>
>
> ~gcc_x86_fenced_block()
> {
> sbarrier();
> }
>
>private:
> static int barrier()
> {
> int r = 0, m = 1;
> __asm__ __volatile__ (
> "xchgl %0, %1" :
> "=r"(r), "=m"(m) :
> "0"(1), "m"(m) :
> "memory", "cc");
> return r;
> }
>
> static void lbarrier()
> {
>
> __asm__ __volatile__ ("lfence" ::: "memory");
>
>
>
> }
>
> static void sbarrier()
> {
>
> __asm__ __volatile__ ("sfence" ::: "memory");
>
>
>
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 88 "/usr/include/boost/asio/detail/gcc_x86_fenced_block.hpp" 2 3 4
># 34 "/usr/include/boost/asio/detail/fenced_block.hpp" 2 3 4
># 45 "/usr/include/boost/asio/detail/fenced_block.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
># 62 "/usr/include/boost/asio/detail/fenced_block.hpp" 3 4
>typedef gcc_x86_fenced_block fenced_block;
># 74 "/usr/include/boost/asio/detail/fenced_block.hpp" 3 4
>}
>}
>}
># 21 "/usr/include/boost/asio/detail/completion_handler.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/operation.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/operation.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>typedef task_io_service_operation operation;
>
>
>}
>}
>}
># 24 "/usr/include/boost/asio/detail/completion_handler.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/completion_handler.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Handler>
>class completion_handler : public operation
>{
>public:
> struct ptr { Handler* h; void* v; completion_handler* p; ~ptr() { reset(); } void reset() { if (p) { p->~completion_handler(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(completion_handler), *h); v = 0; } } };
>
> completion_handler(Handler& h)
> : operation(&completion_handler::do_complete),
> handler_(static_cast<Handler&&>(h))
> {
> }
>
> static void do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> completion_handler* h(static_cast<completion_handler*>(base));
> ptr p = { boost::asio::detail::addressof(h->handler_), h, h };
>
> (void)0;
>
>
>
>
>
>
>
> Handler handler(static_cast<Handler&&>(h->handler_));
> p.h = boost::asio::detail::addressof(handler);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 82 "/usr/include/boost/asio/detail/completion_handler.hpp" 2 3 4
># 20 "/usr/include/boost/asio/detail/impl/task_io_service.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/impl/task_io_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Handler>
>void task_io_service::dispatch(Handler& handler)
>{
> if (thread_call_stack::contains(this))
> {
> fenced_block b(fenced_block::full);
> boost_asio_handler_invoke_helpers::invoke(handler, handler);
> }
> else
> {
>
> typedef completion_handler<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0;
>
> do_dispatch(p.p);
> p.v = p.p = 0;
> }
>}
>
>template <typename Handler>
>void task_io_service::post(Handler& handler)
>{
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef completion_handler<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0;
>
> post_immediate_completion(p.p, is_continuation);
> p.v = p.p = 0;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 79 "/usr/include/boost/asio/detail/impl/task_io_service.hpp" 2 3 4
># 201 "/usr/include/boost/asio/detail/task_io_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/task_io_service.ipp" 1 3 4
># 23 "/usr/include/boost/asio/detail/impl/task_io_service.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/limits.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/impl/task_io_service.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactor.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/reactor.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/object_pool.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/object_pool.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/object_pool.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Object>
>class object_pool;
>
>class object_pool_access
>{
>public:
> template <typename Object>
> static Object* create()
> {
> return new Object;
> }
>
> template <typename Object>
> static void destroy(Object* o)
> {
> delete o;
> }
>
> template <typename Object>
> static Object*& next(Object* o)
> {
> return o->next_;
> }
>
> template <typename Object>
> static Object*& prev(Object* o)
> {
> return o->prev_;
> }
>};
>
>template <typename Object>
>class object_pool
> : private noncopyable
>{
>public:
>
> object_pool()
> : live_list_(0),
> free_list_(0)
> {
> }
>
>
> ~object_pool()
> {
> destroy_list(live_list_);
> destroy_list(free_list_);
> }
>
>
> Object* first()
> {
> return live_list_;
> }
>
>
> Object* alloc()
> {
> Object* o = free_list_;
> if (o)
> free_list_ = object_pool_access::next(free_list_);
> else
> o = object_pool_access::create<Object>();
>
> object_pool_access::next(o) = live_list_;
> object_pool_access::prev(o) = 0;
> if (live_list_)
> object_pool_access::prev(live_list_) = o;
> live_list_ = o;
>
> return o;
> }
>
>
> void free(Object* o)
> {
> if (live_list_ == o)
> live_list_ = object_pool_access::next(o);
>
> if (object_pool_access::prev(o))
> {
> object_pool_access::next(object_pool_access::prev(o))
> = object_pool_access::next(o);
> }
>
> if (object_pool_access::next(o))
> {
> object_pool_access::prev(object_pool_access::next(o))
> = object_pool_access::prev(o);
> }
>
> object_pool_access::next(o) = free_list_;
> object_pool_access::prev(o) = 0;
> free_list_ = o;
> }
>
>private:
>
> void destroy_list(Object* list)
> {
> while (list)
> {
> Object* o = list;
> list = object_pool_access::next(o);
> object_pool_access::destroy(o);
> }
> }
>
>
> Object* live_list_;
>
>
> Object* free_list_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 147 "/usr/include/boost/asio/detail/object_pool.hpp" 2 3 4
># 28 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/reactor_op.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/reactor_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/reactor_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class reactor_op
> : public operation
>{
>public:
>
> boost::system::error_code ec_;
>
>
> std::size_t bytes_transferred_;
>
>
> bool perform()
> {
> return perform_func_(this);
> }
>
>protected:
> typedef bool (*perform_func_type)(reactor_op*);
>
> reactor_op(perform_func_type perform_func, func_type complete_func)
> : operation(complete_func),
> bytes_transferred_(0),
> perform_func_(perform_func)
> {
> }
>
>private:
> perform_func_type perform_func_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 62 "/usr/include/boost/asio/detail/reactor_op.hpp" 2 3 4
># 30 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/select_interrupter.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/select_interrupter.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/eventfd_select_interrupter.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/eventfd_select_interrupter.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/eventfd_select_interrupter.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class eventfd_select_interrupter
>{
>public:
>
> inline eventfd_select_interrupter();
>
>
> inline ~eventfd_select_interrupter();
>
>
> inline void recreate();
>
>
> inline void interrupt();
>
>
> inline bool reset();
>
>
> int read_descriptor() const
> {
> return read_descriptor_;
> }
>
>private:
>
> inline void open_descriptors();
>
>
> inline void close_descriptors();
>
>
>
>
>
> int read_descriptor_;
>
>
>
>
>
> int write_descriptor_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 78 "/usr/include/boost/asio/detail/eventfd_select_interrupter.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 1 3 4
># 23 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 3 4
># 1 "/usr/include/sys/stat.h" 1 3 4
># 103 "/usr/include/sys/stat.h" 3 4
>extern "C" {
>
># 1 "/usr/include/bits/stat.h" 1 3 4
># 46 "/usr/include/bits/stat.h" 3 4
>struct stat
> {
> __dev_t st_dev;
>
>
>
>
> __ino_t st_ino;
>
>
>
>
>
>
>
> __nlink_t st_nlink;
> __mode_t st_mode;
>
> __uid_t st_uid;
> __gid_t st_gid;
>
> int __pad0;
>
> __dev_t st_rdev;
>
>
>
>
> __off_t st_size;
>
>
>
> __blksize_t st_blksize;
>
> __blkcnt_t st_blocks;
># 91 "/usr/include/bits/stat.h" 3 4
> struct timespec st_atim;
> struct timespec st_mtim;
> struct timespec st_ctim;
># 106 "/usr/include/bits/stat.h" 3 4
> __syscall_slong_t __unused[3];
># 115 "/usr/include/bits/stat.h" 3 4
> };
>
>
>
>struct stat64
> {
> __dev_t st_dev;
>
> __ino64_t st_ino;
> __nlink_t st_nlink;
> __mode_t st_mode;
>
>
>
>
>
>
> __uid_t st_uid;
> __gid_t st_gid;
>
> int __pad0;
> __dev_t st_rdev;
> __off_t st_size;
>
>
>
>
>
> __blksize_t st_blksize;
> __blkcnt64_t st_blocks;
>
>
>
>
>
>
>
> struct timespec st_atim;
> struct timespec st_mtim;
> struct timespec st_ctim;
># 164 "/usr/include/bits/stat.h" 3 4
> __syscall_slong_t __unused[3];
>
>
>
> };
># 106 "/usr/include/sys/stat.h" 2 3 4
># 209 "/usr/include/sys/stat.h" 3 4
>extern int stat (const char *__restrict __file,
> struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int fstat (int __fd, struct stat *__buf) throw () __attribute__ ((__nonnull__ (2)));
># 228 "/usr/include/sys/stat.h" 3 4
>extern int stat64 (const char *__restrict __file,
> struct stat64 *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
>extern int fstat64 (int __fd, struct stat64 *__buf) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>
>extern int fstatat (int __fd, const char *__restrict __file,
> struct stat *__restrict __buf, int __flag)
> throw () __attribute__ ((__nonnull__ (2, 3)));
># 253 "/usr/include/sys/stat.h" 3 4
>extern int fstatat64 (int __fd, const char *__restrict __file,
> struct stat64 *__restrict __buf, int __flag)
> throw () __attribute__ ((__nonnull__ (2, 3)));
>
>
>
>
>
>
>
>extern int lstat (const char *__restrict __file,
> struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
># 276 "/usr/include/sys/stat.h" 3 4
>extern int lstat64 (const char *__restrict __file,
> struct stat64 *__restrict __buf)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int chmod (const char *__file, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int lchmod (const char *__file, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int fchmod (int __fd, __mode_t __mode) throw ();
>
>
>
>
>
>extern int fchmodat (int __fd, const char *__file, __mode_t __mode,
> int __flag)
> throw () __attribute__ ((__nonnull__ (2))) ;
>
>
>
>
>
>
>extern __mode_t umask (__mode_t __mask) throw ();
>
>
>
>
>extern __mode_t getumask (void) throw ();
>
>
>
>extern int mkdir (const char *__path, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int mkdirat (int __fd, const char *__path, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int mknodat (int __fd, const char *__path, __mode_t __mode,
> __dev_t __dev) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int mkfifo (const char *__path, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int mkfifoat (int __fd, const char *__path, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int utimensat (int __fd, const char *__path,
> const struct timespec __times[2],
> int __flags)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern int futimens (int __fd, const struct timespec __times[2]) throw ();
># 399 "/usr/include/sys/stat.h" 3 4
>extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf)
> throw () __attribute__ ((__nonnull__ (3)));
>extern int __xstat (int __ver, const char *__filename,
> struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
>extern int __lxstat (int __ver, const char *__filename,
> struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
>extern int __fxstatat (int __ver, int __fildes, const char *__filename,
> struct stat *__stat_buf, int __flag)
> throw () __attribute__ ((__nonnull__ (3, 4)));
># 432 "/usr/include/sys/stat.h" 3 4
>extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
> throw () __attribute__ ((__nonnull__ (3)));
>extern int __xstat64 (int __ver, const char *__filename,
> struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
>extern int __lxstat64 (int __ver, const char *__filename,
> struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
>extern int __fxstatat64 (int __ver, int __fildes, const char *__filename,
> struct stat64 *__stat_buf, int __flag)
> throw () __attribute__ ((__nonnull__ (3, 4)));
>
>extern int __xmknod (int __ver, const char *__path, __mode_t __mode,
> __dev_t *__dev) throw () __attribute__ ((__nonnull__ (2, 4)));
>
>extern int __xmknodat (int __ver, int __fd, const char *__path,
> __mode_t __mode, __dev_t *__dev)
> throw () __attribute__ ((__nonnull__ (3, 5)));
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) stat (const char *__path, struct stat *__statbuf) throw ()
>{
> return __xstat (1, __path, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) lstat (const char *__path, struct stat *__statbuf) throw ()
>{
> return __lxstat (1, __path, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) fstat (int __fd, struct stat *__statbuf) throw ()
>{
> return __fxstat (1, __fd, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) fstatat (int __fd, const char *__filename, struct stat *__statbuf, int __flag) throw ()
>
>{
> return __fxstatat (1, __fd, __filename, __statbuf, __flag);
>}
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) mknod (const char *__path, __mode_t __mode, __dev_t __dev) throw ()
>{
> return __xmknod (0, __path, __mode, &__dev);
>}
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) mknodat (int __fd, const char *__path, __mode_t __mode, __dev_t __dev) throw ()
>
>{
> return __xmknodat (0, __fd, __path, __mode, &__dev);
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) stat64 (const char *__path, struct stat64 *__statbuf) throw ()
>{
> return __xstat64 (1, __path, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) lstat64 (const char *__path, struct stat64 *__statbuf) throw ()
>{
> return __lxstat64 (1, __path, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) fstat64 (int __fd, struct stat64 *__statbuf) throw ()
>{
> return __fxstat64 (1, __fd, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) fstatat64 (int __fd, const char *__filename, struct stat64 *__statbuf, int __flag) throw ()
>
>{
> return __fxstatat64 (1, __fd, __filename, __statbuf, __flag);
>}
>
>
>
>
>
>
>}
># 24 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
>
># 1 "/usr/include/fcntl.h" 1 3 4
># 28 "/usr/include/fcntl.h" 3 4
>extern "C" {
>
>
>
>
>
>
># 1 "/usr/include/bits/fcntl.h" 1 3 4
># 35 "/usr/include/bits/fcntl.h" 3 4
>struct flock
> {
> short int l_type;
> short int l_whence;
>
> __off_t l_start;
> __off_t l_len;
>
>
>
>
> __pid_t l_pid;
> };
>
>
>struct flock64
> {
> short int l_type;
> short int l_whence;
> __off64_t l_start;
> __off64_t l_len;
> __pid_t l_pid;
> };
>
>
>
># 1 "/usr/include/bits/fcntl-linux.h" 1 3 4
># 38 "/usr/include/bits/fcntl-linux.h" 3 4
># 1 "/usr/include/bits/uio.h" 1 3 4
># 39 "/usr/include/bits/fcntl-linux.h" 2 3 4
># 237 "/usr/include/bits/fcntl-linux.h" 3 4
>enum __pid_type
> {
> F_OWNER_TID = 0,
> F_OWNER_PID,
> F_OWNER_PGRP,
> F_OWNER_GID = F_OWNER_PGRP
> };
>
>
>struct f_owner_ex
> {
> enum __pid_type type;
> __pid_t pid;
> };
># 307 "/usr/include/bits/fcntl-linux.h" 3 4
>struct file_handle
>{
> unsigned int handle_bytes;
> int handle_type;
>
> unsigned char f_handle[0];
>};
>
>
>
>
>
>extern "C" {
>
>
>
>
>extern ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
> throw ();
>
>
>
>
>
>
>extern int sync_file_range (int __fd, __off64_t __offset, __off64_t __count,
> unsigned int __flags);
>
>
>
>
>
>
>extern ssize_t vmsplice (int __fdout, const struct iovec *__iov,
> size_t __count, unsigned int __flags);
>
>
>
>
>
>extern ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
> __off64_t *__offout, size_t __len,
> unsigned int __flags);
>
>
>
>
>
>extern ssize_t tee (int __fdin, int __fdout, size_t __len,
> unsigned int __flags);
>
>
>
>
>
>
>extern int fallocate (int __fd, int __mode, __off_t __offset, __off_t __len);
># 374 "/usr/include/bits/fcntl-linux.h" 3 4
>extern int fallocate64 (int __fd, int __mode, __off64_t __offset,
> __off64_t __len);
>
>
>
>
>extern int name_to_handle_at (int __dfd, const char *__name,
> struct file_handle *__handle, int *__mnt_id,
> int __flags) throw ();
>
>
>
>
>
>extern int open_by_handle_at (int __mountdirfd, struct file_handle *__handle,
> int __flags);
>
>
>
>}
># 61 "/usr/include/bits/fcntl.h" 2 3 4
># 36 "/usr/include/fcntl.h" 2 3 4
># 68 "/usr/include/fcntl.h" 3 4
># 1 "/usr/include/bits/stat.h" 1 3 4
># 69 "/usr/include/fcntl.h" 2 3 4
># 160 "/usr/include/fcntl.h" 3 4
>extern int fcntl (int __fd, int __cmd, ...);
># 169 "/usr/include/fcntl.h" 3 4
>extern int open (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
># 179 "/usr/include/fcntl.h" 3 4
>extern int open64 (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
># 193 "/usr/include/fcntl.h" 3 4
>extern int openat (int __fd, const char *__file, int __oflag, ...)
> __attribute__ ((__nonnull__ (2)));
># 204 "/usr/include/fcntl.h" 3 4
>extern int openat64 (int __fd, const char *__file, int __oflag, ...)
> __attribute__ ((__nonnull__ (2)));
># 215 "/usr/include/fcntl.h" 3 4
>extern int creat (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
># 225 "/usr/include/fcntl.h" 3 4
>extern int creat64 (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
># 261 "/usr/include/fcntl.h" 3 4
>extern int posix_fadvise (int __fd, off_t __offset, off_t __len,
> int __advise) throw ();
># 273 "/usr/include/fcntl.h" 3 4
>extern int posix_fadvise64 (int __fd, off64_t __offset, off64_t __len,
> int __advise) throw ();
># 283 "/usr/include/fcntl.h" 3 4
>extern int posix_fallocate (int __fd, off_t __offset, off_t __len);
># 294 "/usr/include/fcntl.h" 3 4
>extern int posix_fallocate64 (int __fd, off64_t __offset, off64_t __len);
># 305 "/usr/include/fcntl.h" 3 4
>}
># 26 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
>
>
>
># 1 "/usr/include/sys/eventfd.h" 1 3 4
># 24 "/usr/include/sys/eventfd.h" 3 4
># 1 "/usr/include/bits/eventfd.h" 1 3 4
># 23 "/usr/include/bits/eventfd.h" 3 4
>enum
> {
> EFD_SEMAPHORE = 00000001,
>
> EFD_CLOEXEC = 02000000,
>
> EFD_NONBLOCK = 00004000
>
> };
># 25 "/usr/include/sys/eventfd.h" 2 3 4
>
>
>typedef uint64_t eventfd_t;
>
>
>extern "C" {
>
>
>
>extern int eventfd (int __count, int __flags) throw ();
>
>
>extern int eventfd_read (int __fd, eventfd_t *__value);
>
>
>extern int eventfd_write (int __fd, eventfd_t __value);
>
>}
># 30 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/cstdint.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/cstdint.hpp" 3 4
>namespace boost {
>namespace asio {
>
>
>using std::int16_t;
>using std::uint16_t;
>using std::int32_t;
>using std::uint32_t;
>using std::int64_t;
>using std::uint64_t;
># 45 "/usr/include/boost/asio/detail/cstdint.hpp" 3 4
>}
>}
># 32 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/eventfd_select_interrupter.hpp" 1 3 4
># 33 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 37 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>eventfd_select_interrupter::eventfd_select_interrupter()
>{
> open_descriptors();
>}
>
>void eventfd_select_interrupter::open_descriptors()
>{
># 58 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 3 4
> write_descriptor_ = read_descriptor_ =
> ::eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
>
>
>
>
> if (read_descriptor_ == -1 && (*__errno_location ()) == 22)
> {
> write_descriptor_ = read_descriptor_ = ::eventfd(0, 0);
> if (read_descriptor_ != -1)
> {
> ::fcntl(read_descriptor_, 4, 04000);
> ::fcntl(read_descriptor_, 2, 1);
> }
> }
>
>
> if (read_descriptor_ == -1)
> {
> int pipe_fds[2];
> if (pipe(pipe_fds) == 0)
> {
> read_descriptor_ = pipe_fds[0];
> ::fcntl(read_descriptor_, 4, 04000);
> ::fcntl(read_descriptor_, 2, 1);
> write_descriptor_ = pipe_fds[1];
> ::fcntl(write_descriptor_, 4, 04000);
> ::fcntl(write_descriptor_, 2, 1);
> }
> else
> {
> boost::system::error_code ec((*__errno_location ()),
> boost::asio::error::get_system_category());
> boost::asio::detail::throw_error(ec, "eventfd_select_interrupter");
> }
> }
>}
>
>eventfd_select_interrupter::~eventfd_select_interrupter()
>{
> close_descriptors();
>}
>
>void eventfd_select_interrupter::close_descriptors()
>{
> if (write_descriptor_ != -1 && write_descriptor_ != read_descriptor_)
> ::close(write_descriptor_);
> if (read_descriptor_ != -1)
> ::close(read_descriptor_);
>}
>
>void eventfd_select_interrupter::recreate()
>{
> close_descriptors();
>
> write_descriptor_ = -1;
> read_descriptor_ = -1;
>
> open_descriptors();
>}
>
>void eventfd_select_interrupter::interrupt()
>{
> uint64_t counter(1UL);
> int result = ::write(write_descriptor_, &counter, sizeof(uint64_t));
> (void)result;
>}
>
>bool eventfd_select_interrupter::reset()
>{
> if (write_descriptor_ == read_descriptor_)
> {
> for (;;)
> {
>
> uint64_t counter(0);
> (*__errno_location ()) = 0;
> int bytes_read = ::read(read_descriptor_, &counter, sizeof(uint64_t));
> if (bytes_read < 0 && (*__errno_location ()) == 4)
> continue;
> bool was_interrupted = (bytes_read > 0);
> return was_interrupted;
> }
> }
> else
> {
> for (;;)
> {
>
> char data[1024];
> int bytes_read = ::read(read_descriptor_, data, sizeof(data));
> if (bytes_read < 0 && (*__errno_location ()) == 4)
> continue;
> bool was_interrupted = (bytes_read > 0);
> while (bytes_read == sizeof(data))
> bytes_read = ::read(read_descriptor_, data, sizeof(data));
> return was_interrupted;
> }
> }
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 164 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
># 81 "/usr/include/boost/asio/detail/eventfd_select_interrupter.hpp" 2 3 4
># 24 "/usr/include/boost/asio/detail/select_interrupter.hpp" 2 3 4
>
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>typedef eventfd_select_interrupter select_interrupter;
>
>
>
>
>}
>}
>}
># 31 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/socket_types.hpp" 1 3 4
># 48 "/usr/include/boost/asio/detail/socket_types.hpp" 3 4
># 1 "/usr/include/sys/ioctl.h" 1 3 4
># 23 "/usr/include/sys/ioctl.h" 3 4
>extern "C" {
>
>
># 1 "/usr/include/bits/ioctls.h" 1 3 4
># 23 "/usr/include/bits/ioctls.h" 3 4
># 1 "/usr/include/asm/ioctls.h" 1 3 4
># 1 "/usr/include/asm-generic/ioctls.h" 1 3 4
>
>
>
># 1 "/usr/include/linux/ioctl.h" 1 3 4
>
>
>
># 1 "/usr/include/asm/ioctl.h" 1 3 4
># 1 "/usr/include/asm-generic/ioctl.h" 1 3 4
># 1 "/usr/include/asm/ioctl.h" 2 3 4
># 5 "/usr/include/linux/ioctl.h" 2 3 4
># 5 "/usr/include/asm-generic/ioctls.h" 2 3 4
># 1 "/usr/include/asm/ioctls.h" 2 3 4
># 24 "/usr/include/bits/ioctls.h" 2 3 4
># 27 "/usr/include/sys/ioctl.h" 2 3 4
>
>
># 1 "/usr/include/bits/ioctl-types.h" 1 3 4
># 24 "/usr/include/bits/ioctl-types.h" 3 4
># 1 "/usr/include/asm/ioctls.h" 1 3 4
># 25 "/usr/include/bits/ioctl-types.h" 2 3 4
>
>
>struct winsize
> {
> unsigned short int ws_row;
> unsigned short int ws_col;
> unsigned short int ws_xpixel;
> unsigned short int ws_ypixel;
> };
>
>
>struct termio
> {
> unsigned short int c_iflag;
> unsigned short int c_oflag;
> unsigned short int c_cflag;
> unsigned short int c_lflag;
> unsigned char c_line;
> unsigned char c_cc[8];
>};
># 30 "/usr/include/sys/ioctl.h" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/sys/ttydefaults.h" 1 3 4
># 37 "/usr/include/sys/ioctl.h" 2 3 4
>
>
>
>
>extern int ioctl (int __fd, unsigned long int __request, ...) throw ();
>
>}
># 49 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
>
># 1 "/usr/include/sys/poll.h" 1 3 4
># 25 "/usr/include/sys/poll.h" 3 4
># 1 "/usr/include/bits/poll.h" 1 3 4
># 26 "/usr/include/sys/poll.h" 2 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 29 "/usr/include/sys/poll.h" 2 3 4
>
>
>
>
>
>
>
>typedef unsigned long int nfds_t;
>
>
>struct pollfd
> {
> int fd;
> short int events;
> short int revents;
> };
>
>
>extern "C" {
># 57 "/usr/include/sys/poll.h" 3 4
>extern int poll (struct pollfd *__fds, nfds_t __nfds, int __timeout);
># 66 "/usr/include/sys/poll.h" 3 4
>extern int ppoll (struct pollfd *__fds, nfds_t __nfds,
> const struct timespec *__timeout,
> const __sigset_t *__ss);
>
>
>}
># 51 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
># 63 "/usr/include/boost/asio/detail/socket_types.hpp" 3 4
># 1 "/usr/include/sys/un.h" 1 3 4
># 26 "/usr/include/sys/un.h" 3 4
>extern "C" {
>
>
>struct sockaddr_un
> {
> sa_family_t sun_family;
> char sun_path[108];
> };
># 44 "/usr/include/sys/un.h" 3 4
>}
># 64 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
>
>
># 1 "/usr/include/netinet/tcp.h" 1 3 4
># 102 "/usr/include/netinet/tcp.h" 3 4
>struct tcphdr
> {
> u_int16_t source;
> u_int16_t dest;
> u_int32_t seq;
> u_int32_t ack_seq;
>
> u_int16_t res1:4;
> u_int16_t doff:4;
> u_int16_t fin:1;
> u_int16_t syn:1;
> u_int16_t rst:1;
> u_int16_t psh:1;
> u_int16_t ack:1;
> u_int16_t urg:1;
> u_int16_t res2:2;
># 131 "/usr/include/netinet/tcp.h" 3 4
> u_int16_t window;
> u_int16_t check;
> u_int16_t urg_ptr;
>};
>
>
>enum
>{
> TCP_ESTABLISHED = 1,
> TCP_SYN_SENT,
> TCP_SYN_RECV,
> TCP_FIN_WAIT1,
> TCP_FIN_WAIT2,
> TCP_TIME_WAIT,
> TCP_CLOSE,
> TCP_CLOSE_WAIT,
> TCP_LAST_ACK,
> TCP_LISTEN,
> TCP_CLOSING
>};
># 191 "/usr/include/netinet/tcp.h" 3 4
>enum tcp_ca_state
>{
> TCP_CA_Open = 0,
> TCP_CA_Disorder = 1,
> TCP_CA_CWR = 2,
> TCP_CA_Recovery = 3,
> TCP_CA_Loss = 4
>};
>
>struct tcp_info
>{
> u_int8_t tcpi_state;
> u_int8_t tcpi_ca_state;
> u_int8_t tcpi_retransmits;
> u_int8_t tcpi_probes;
> u_int8_t tcpi_backoff;
> u_int8_t tcpi_options;
> u_int8_t tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4;
>
> u_int32_t tcpi_rto;
> u_int32_t tcpi_ato;
> u_int32_t tcpi_snd_mss;
> u_int32_t tcpi_rcv_mss;
>
> u_int32_t tcpi_unacked;
> u_int32_t tcpi_sacked;
> u_int32_t tcpi_lost;
> u_int32_t tcpi_retrans;
> u_int32_t tcpi_fackets;
>
>
> u_int32_t tcpi_last_data_sent;
> u_int32_t tcpi_last_ack_sent;
> u_int32_t tcpi_last_data_recv;
> u_int32_t tcpi_last_ack_recv;
>
>
> u_int32_t tcpi_pmtu;
> u_int32_t tcpi_rcv_ssthresh;
> u_int32_t tcpi_rtt;
> u_int32_t tcpi_rttvar;
> u_int32_t tcpi_snd_ssthresh;
> u_int32_t tcpi_snd_cwnd;
> u_int32_t tcpi_advmss;
> u_int32_t tcpi_reordering;
>
> u_int32_t tcpi_rcv_rtt;
> u_int32_t tcpi_rcv_space;
>
> u_int32_t tcpi_total_retrans;
>};
>
>
>
>
>
>struct tcp_md5sig
>{
> struct sockaddr_storage tcpm_addr;
> u_int16_t __tcpm_pad1;
> u_int16_t tcpm_keylen;
> u_int32_t __tcpm_pad2;
> u_int8_t tcpm_key[80];
>};
>
>
>struct tcp_repair_opt
>{
> u_int32_t opt_code;
> u_int32_t opt_val;
>};
>
>
>enum
>{
> TCP_NO_QUEUE,
> TCP_RECV_QUEUE,
> TCP_SEND_QUEUE,
> TCP_QUEUES_NR,
>};
># 289 "/usr/include/netinet/tcp.h" 3 4
>struct tcp_cookie_transactions
>{
> u_int16_t tcpct_flags;
> u_int8_t __tcpct_pad1;
> u_int8_t tcpct_cookie_desired;
> u_int16_t tcpct_s_data_desired;
> u_int16_t tcpct_used;
> u_int8_t tcpct_value[536U];
>};
># 67 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
>
># 1 "/usr/include/arpa/inet.h" 1 3 4
># 30 "/usr/include/arpa/inet.h" 3 4
>extern "C" {
>
>
>
>extern in_addr_t inet_addr (const char *__cp) throw ();
>
>
>extern in_addr_t inet_lnaof (struct in_addr __in) throw ();
>
>
>
>extern struct in_addr inet_makeaddr (in_addr_t __net, in_addr_t __host)
> throw ();
>
>
>extern in_addr_t inet_netof (struct in_addr __in) throw ();
>
>
>
>extern in_addr_t inet_network (const char *__cp) throw ();
>
>
>
>extern char *inet_ntoa (struct in_addr __in) throw ();
>
>
>
>
>extern int inet_pton (int __af, const char *__restrict __cp,
> void *__restrict __buf) throw ();
>
>
>
>
>extern const char *inet_ntop (int __af, const void *__restrict __cp,
> char *__restrict __buf, socklen_t __len)
> throw ();
>
>
>
>
>
>
>extern int inet_aton (const char *__cp, struct in_addr *__inp) throw ();
>
>
>
>extern char *inet_neta (in_addr_t __net, char *__buf, size_t __len) throw ();
>
>
>
>
>extern char *inet_net_ntop (int __af, const void *__cp, int __bits,
> char *__buf, size_t __len) throw ();
>
>
>
>
>extern int inet_net_pton (int __af, const char *__cp,
> void *__buf, size_t __len) throw ();
>
>
>
>
>extern unsigned int inet_nsap_addr (const char *__cp,
> unsigned char *__buf, int __len) throw ();
>
>
>
>extern char *inet_nsap_ntoa (int __len, const unsigned char *__cp,
> char *__buf) throw ();
>
>
>}
># 69 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
>
># 1 "/usr/include/net/if.h" 1 3 4
># 33 "/usr/include/net/if.h" 3 4
>struct if_nameindex
> {
> unsigned int if_index;
> char *if_name;
> };
>
>
>
>
>enum
> {
> IFF_UP = 0x1,
>
> IFF_BROADCAST = 0x2,
>
> IFF_DEBUG = 0x4,
>
> IFF_LOOPBACK = 0x8,
>
> IFF_POINTOPOINT = 0x10,
>
> IFF_NOTRAILERS = 0x20,
>
> IFF_RUNNING = 0x40,
>
> IFF_NOARP = 0x80,
>
> IFF_PROMISC = 0x100,
>
>
>
> IFF_ALLMULTI = 0x200,
>
>
> IFF_MASTER = 0x400,
>
> IFF_SLAVE = 0x800,
>
>
> IFF_MULTICAST = 0x1000,
>
>
> IFF_PORTSEL = 0x2000,
>
> IFF_AUTOMEDIA = 0x4000,
>
> IFF_DYNAMIC = 0x8000
>
> };
>
>
>
>
>
>
>struct ifaddr
> {
> struct sockaddr ifa_addr;
> union
> {
> struct sockaddr ifu_broadaddr;
> struct sockaddr ifu_dstaddr;
> } ifa_ifu;
> struct iface *ifa_ifp;
> struct ifaddr *ifa_next;
> };
># 111 "/usr/include/net/if.h" 3 4
>struct ifmap
> {
> unsigned long int mem_start;
> unsigned long int mem_end;
> unsigned short int base_addr;
> unsigned char irq;
> unsigned char dma;
> unsigned char port;
>
> };
>
>
>
>
>
>struct ifreq
> {
>
>
> union
> {
> char ifrn_name[16];
> } ifr_ifrn;
>
> union
> {
> struct sockaddr ifru_addr;
> struct sockaddr ifru_dstaddr;
> struct sockaddr ifru_broadaddr;
> struct sockaddr ifru_netmask;
> struct sockaddr ifru_hwaddr;
> short int ifru_flags;
> int ifru_ivalue;
> int ifru_mtu;
> struct ifmap ifru_map;
> char ifru_slave[16];
> char ifru_newname[16];
> __caddr_t ifru_data;
> } ifr_ifru;
> };
># 176 "/usr/include/net/if.h" 3 4
>struct ifconf
> {
> int ifc_len;
> union
> {
> __caddr_t ifcu_buf;
> struct ifreq *ifcu_req;
> } ifc_ifcu;
> };
>
>
>
>
>
>extern "C" {
>
>
>extern unsigned int if_nametoindex (const char *__ifname) throw ();
>extern char *if_indextoname (unsigned int __ifindex, char *__ifname) throw ();
>
>
>extern struct if_nameindex *if_nameindex (void) throw ();
>
>
>extern void if_freenameindex (struct if_nameindex *__ptr) throw ();
>
>}
># 71 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
># 72 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 79 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
># 124 "/usr/include/boost/asio/detail/socket_types.hpp" 3 4
>typedef int socket_type;
>const int invalid_socket = -1;
>const int socket_error_retval = -1;
>const int max_addr_v4_str_len = 16;
>
>const int max_addr_v6_str_len = 46 + 1 + 16;
>
>
>
>typedef sockaddr socket_addr_type;
>typedef in_addr in4_addr_type;
># 143 "/usr/include/boost/asio/detail/socket_types.hpp" 3 4
>typedef ip_mreq in4_mreq_type;
>
>typedef sockaddr_in sockaddr_in4_type;
>typedef in6_addr in6_addr_type;
>typedef ipv6_mreq in6_mreq_type;
>typedef sockaddr_in6 sockaddr_in6_type;
>typedef sockaddr_storage sockaddr_storage_type;
>typedef sockaddr_un sockaddr_un_type;
>typedef addrinfo addrinfo_type;
>typedef int ioctl_arg_type;
>typedef uint32_t u_long_type;
>typedef uint16_t u_short_type;
>
>typedef ssize_t signed_size_type;
>
>
>
>const int shutdown_receive = SHUT_RD;
>const int shutdown_send = SHUT_WR;
>const int shutdown_both = SHUT_RDWR;
>const int message_peek = MSG_PEEK;
>const int message_out_of_band = MSG_OOB;
>const int message_do_not_route = MSG_DONTROUTE;
>const int message_end_of_record = MSG_EOR;
>
>const int max_iov_len = 1024;
>
>
>
>
>
>const int custom_socket_option_level = 0xA5100000;
>const int enable_connection_aborted_option = 1;
>const int always_fail_option = 2;
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 183 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
># 32 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/timer_queue_base.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/timer_queue_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/timer_queue_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class timer_queue_base
> : private noncopyable
>{
>public:
>
> timer_queue_base() : next_(0) {}
>
>
> virtual ~timer_queue_base() {}
>
>
> virtual bool empty() const = 0;
>
>
> virtual long wait_duration_msec(long max_duration) const = 0;
>
>
> virtual long wait_duration_usec(long max_duration) const = 0;
>
>
> virtual void get_ready_timers(op_queue<operation>& ops) = 0;
>
>
> virtual void get_all_timers(op_queue<operation>& ops) = 0;
>
>private:
> friend class timer_queue_set;
>
>
> timer_queue_base* next_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 66 "/usr/include/boost/asio/detail/timer_queue_base.hpp" 2 3 4
># 33 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/timer_queue_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/asio/detail/timer_queue_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Time_Traits>
>class timer_queue;
>
>}
>}
>}
># 34 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/timer_queue_set.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/timer_queue_set.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/timer_queue_set.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class timer_queue_set
>{
>public:
>
> inline timer_queue_set();
>
>
> inline void insert(timer_queue_base* q);
>
>
> inline void erase(timer_queue_base* q);
>
>
> inline bool all_empty() const;
>
>
> inline long wait_duration_msec(long max_duration) const;
>
>
> inline long wait_duration_usec(long max_duration) const;
>
>
> inline void get_ready_timers(op_queue<operation>& ops);
>
>
> inline void get_all_timers(op_queue<operation>& ops);
>
>private:
> timer_queue_base* first_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 63 "/usr/include/boost/asio/detail/timer_queue_set.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/timer_queue_set.ipp" 1 3 4
># 19 "/usr/include/boost/asio/detail/impl/timer_queue_set.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/timer_queue_set.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/timer_queue_set.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/impl/timer_queue_set.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>timer_queue_set::timer_queue_set()
> : first_(0)
>{
>}
>
>void timer_queue_set::insert(timer_queue_base* q)
>{
> q->next_ = first_;
> first_ = q;
>}
>
>void timer_queue_set::erase(timer_queue_base* q)
>{
> if (first_)
> {
> if (q == first_)
> {
> first_ = q->next_;
> q->next_ = 0;
> return;
> }
>
> for (timer_queue_base* p = first_; p->next_; p = p->next_)
> {
> if (p->next_ == q)
> {
> p->next_ = q->next_;
> q->next_ = 0;
> return;
> }
> }
> }
>}
>
>bool timer_queue_set::all_empty() const
>{
> for (timer_queue_base* p = first_; p; p = p->next_)
> if (!p->empty())
> return false;
> return true;
>}
>
>long timer_queue_set::wait_duration_msec(long max_duration) const
>{
> long min_duration = max_duration;
> for (timer_queue_base* p = first_; p; p = p->next_)
> min_duration = p->wait_duration_msec(min_duration);
> return min_duration;
>}
>
>long timer_queue_set::wait_duration_usec(long max_duration) const
>{
> long min_duration = max_duration;
> for (timer_queue_base* p = first_; p; p = p->next_)
> min_duration = p->wait_duration_usec(min_duration);
> return min_duration;
>}
>
>void timer_queue_set::get_ready_timers(op_queue<operation>& ops)
>{
> for (timer_queue_base* p = first_; p; p = p->next_)
> p->get_ready_timers(ops);
>}
>
>void timer_queue_set::get_all_timers(op_queue<operation>& ops)
>{
> for (timer_queue_base* p = first_; p; p = p->next_)
> p->get_all_timers(ops);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 102 "/usr/include/boost/asio/detail/impl/timer_queue_set.ipp" 2 3 4
># 66 "/usr/include/boost/asio/detail/timer_queue_set.hpp" 2 3 4
># 35 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/wait_op.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/wait_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/wait_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class wait_op
> : public operation
>{
>public:
>
> boost::system::error_code ec_;
>
>protected:
> wait_op(func_type func)
> : operation(func)
> {
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 46 "/usr/include/boost/asio/detail/wait_op.hpp" 2 3 4
># 36 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 38 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class epoll_reactor
> : public boost::asio::detail::service_base<epoll_reactor>
>{
>public:
> enum op_types { read_op = 0, write_op = 1,
> connect_op = 1, except_op = 2, max_ops = 3 };
>
>
> class descriptor_state : operation
> {
> friend class epoll_reactor;
> friend class object_pool_access;
>
> descriptor_state* next_;
> descriptor_state* prev_;
>
> mutex mutex_;
> epoll_reactor* reactor_;
> int descriptor_;
> uint32_t registered_events_;
> op_queue<reactor_op> op_queue_[max_ops];
> bool shutdown_;
>
> inline descriptor_state();
> void set_ready_events(uint32_t events) { task_result_ = events; }
> inline operation* perform_io(uint32_t events);
> inline static void do_complete(
> io_service_impl* owner, operation* base,
> const boost::system::error_code& ec, std::size_t bytes_transferred);
> };
>
>
> typedef descriptor_state* per_descriptor_data;
>
>
> inline epoll_reactor(boost::asio::io_service& io_service);
>
>
> inline ~epoll_reactor();
>
>
> inline void shutdown_service();
>
>
> inline void fork_service(
> boost::asio::io_service::fork_event fork_ev);
>
>
> inline void init_task();
>
>
>
> inline int register_descriptor(socket_type descriptor,
> per_descriptor_data& descriptor_data);
>
>
>
> inline int register_internal_descriptor(
> int op_type, socket_type descriptor,
> per_descriptor_data& descriptor_data, reactor_op* op);
>
>
> inline void move_descriptor(socket_type descriptor,
> per_descriptor_data& target_descriptor_data,
> per_descriptor_data& source_descriptor_data);
>
>
> void post_immediate_completion(reactor_op* op, bool is_continuation)
> {
> io_service_.post_immediate_completion(op, is_continuation);
> }
>
>
>
> inline void start_op(int op_type, socket_type descriptor,
> per_descriptor_data& descriptor_data, reactor_op* op,
> bool is_continuation, bool allow_speculative);
>
>
>
>
> inline void cancel_ops(socket_type descriptor,
> per_descriptor_data& descriptor_data);
>
>
>
> inline void deregister_descriptor(socket_type descriptor,
> per_descriptor_data& descriptor_data, bool closing);
>
>
> inline void deregister_internal_descriptor(
> socket_type descriptor, per_descriptor_data& descriptor_data);
>
>
> template <typename Time_Traits>
> void add_timer_queue(timer_queue<Time_Traits>& timer_queue);
>
>
> template <typename Time_Traits>
> void remove_timer_queue(timer_queue<Time_Traits>& timer_queue);
>
>
>
> template <typename Time_Traits>
> void schedule_timer(timer_queue<Time_Traits>& queue,
> const typename Time_Traits::time_type& time,
> typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
>
>
>
> template <typename Time_Traits>
> std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
> typename timer_queue<Time_Traits>::per_timer_data& timer,
> std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
>
>
> inline void run(bool block, op_queue<operation>& ops);
>
>
> inline void interrupt();
>
>private:
>
> enum { epoll_size = 20000 };
>
>
>
> inline static int do_epoll_create();
>
>
> inline static int do_timerfd_create();
>
>
> inline descriptor_state* allocate_descriptor_state();
>
>
> inline void free_descriptor_state(descriptor_state* s);
>
>
> inline void do_add_timer_queue(timer_queue_base& queue);
>
>
> inline void do_remove_timer_queue(timer_queue_base& queue);
>
>
> inline void update_timeout();
>
>
>
>
> inline int get_timeout();
>
>
>
>
> inline int get_timeout(itimerspec& ts);
>
>
>
> io_service_impl& io_service_;
>
>
> mutex mutex_;
>
>
> select_interrupter interrupter_;
>
>
> int epoll_fd_;
>
>
> int timer_fd_;
>
>
> timer_queue_set timer_queues_;
>
>
> bool shutdown_;
>
>
> mutex registered_descriptors_mutex_;
>
>
> object_pool<descriptor_state> registered_descriptors_;
>
>
> struct perform_io_cleanup_on_block_exit;
> friend struct perform_io_cleanup_on_block_exit;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 238 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/epoll_reactor.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/epoll_reactor.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/impl/epoll_reactor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Time_Traits>
>void epoll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
>{
> do_add_timer_queue(queue);
>}
>
>template <typename Time_Traits>
>void epoll_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
>{
> do_remove_timer_queue(queue);
>}
>
>template <typename Time_Traits>
>void epoll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
> const typename Time_Traits::time_type& time,
> typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
>{
> mutex::scoped_lock lock(mutex_);
>
> if (shutdown_)
> {
> io_service_.post_immediate_completion(op, false);
> return;
> }
>
> bool earliest = queue.enqueue_timer(time, timer, op);
> io_service_.work_started();
> if (earliest)
> update_timeout();
>}
>
>template <typename Time_Traits>
>std::size_t epoll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
> typename timer_queue<Time_Traits>::per_timer_data& timer,
> std::size_t max_cancelled)
>{
> mutex::scoped_lock lock(mutex_);
> op_queue<operation> ops;
> std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
> lock.unlock();
> io_service_.post_deferred_completions(ops);
> return n;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 75 "/usr/include/boost/asio/detail/impl/epoll_reactor.hpp" 2 3 4
># 240 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 1 3 4
># 22 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 23 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 2 3 4
># 1 "/usr/include/sys/epoll.h" 1 3 4
># 25 "/usr/include/sys/epoll.h" 3 4
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 26 "/usr/include/sys/epoll.h" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/bits/epoll.h" 1 3 4
># 23 "/usr/include/bits/epoll.h" 3 4
>enum
> {
> EPOLL_CLOEXEC = 02000000
>
> };
># 34 "/usr/include/sys/epoll.h" 2 3 4
>
>
>
>
>
>
>enum EPOLL_EVENTS
> {
> EPOLLIN = 0x001,
>
> EPOLLPRI = 0x002,
>
> EPOLLOUT = 0x004,
>
> EPOLLRDNORM = 0x040,
>
> EPOLLRDBAND = 0x080,
>
> EPOLLWRNORM = 0x100,
>
> EPOLLWRBAND = 0x200,
>
> EPOLLMSG = 0x400,
>
> EPOLLERR = 0x008,
>
> EPOLLHUP = 0x010,
>
> EPOLLRDHUP = 0x2000,
>
> EPOLLWAKEUP = 1u << 29,
>
> EPOLLONESHOT = 1u << 30,
>
> EPOLLET = 1u << 31
>
> };
># 79 "/usr/include/sys/epoll.h" 3 4
>typedef union epoll_data
>{
> void *ptr;
> int fd;
> uint32_t u32;
> uint64_t u64;
>} epoll_data_t;
>
>struct epoll_event
>{
> uint32_t events;
> epoll_data_t data;
>} __attribute__ ((__packed__));
>
>
>extern "C" {
>
>
>
>
>
>extern int epoll_create (int __size) throw ();
>
>
>
>extern int epoll_create1 (int __flags) throw ();
># 113 "/usr/include/sys/epoll.h" 3 4
>extern int epoll_ctl (int __epfd, int __op, int __fd,
> struct epoll_event *__event) throw ();
># 127 "/usr/include/sys/epoll.h" 3 4
>extern int epoll_wait (int __epfd, struct epoll_event *__events,
> int __maxevents, int __timeout);
>
>
>
>
>
>
>
>extern int epoll_pwait (int __epfd, struct epoll_event *__events,
> int __maxevents, int __timeout,
> const __sigset_t *__ss);
>
>}
># 24 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 2 3 4
>
>
>
>
># 1 "/usr/include/sys/timerfd.h" 1 3 4
># 24 "/usr/include/sys/timerfd.h" 3 4
># 1 "/usr/include/bits/timerfd.h" 1 3 4
># 23 "/usr/include/bits/timerfd.h" 3 4
>enum
> {
> TFD_CLOEXEC = 02000000,
>
> TFD_NONBLOCK = 00004000
>
> };
># 25 "/usr/include/sys/timerfd.h" 2 3 4
>
>
>
>enum
> {
> TFD_TIMER_ABSTIME = 1 << 0
>
> };
>
>
>extern "C" {
>
>
>extern int timerfd_create (clockid_t __clock_id, int __flags) throw ();
>
>
>
>
>extern int timerfd_settime (int __ufd, int __flags,
> const struct itimerspec *__utmr,
> struct itimerspec *__otmr) throw ();
>
>
>extern int timerfd_gettime (int __ufd, struct itimerspec *__otmr) throw ();
>
>}
># 30 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 33 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>epoll_reactor::epoll_reactor(boost::asio::io_service& io_service)
> : boost::asio::detail::service_base<epoll_reactor>(io_service),
> io_service_(use_service<io_service_impl>(io_service)),
> mutex_(),
> interrupter_(),
> epoll_fd_(do_epoll_create()),
> timer_fd_(do_timerfd_create()),
> shutdown_(false)
>{
>
> epoll_event ev = { 0, { 0 } };
> ev.events = EPOLLIN | EPOLLERR | EPOLLET;
> ev.data.ptr = &interrupter_;
> epoll_ctl(epoll_fd_, 1, interrupter_.read_descriptor(), &ev);
> interrupter_.interrupt();
>
>
> if (timer_fd_ != -1)
> {
> ev.events = EPOLLIN | EPOLLERR;
> ev.data.ptr = &timer_fd_;
> epoll_ctl(epoll_fd_, 1, timer_fd_, &ev);
> }
>}
>
>epoll_reactor::~epoll_reactor()
>{
> if (epoll_fd_ != -1)
> close(epoll_fd_);
> if (timer_fd_ != -1)
> close(timer_fd_);
>}
>
>void epoll_reactor::shutdown_service()
>{
> mutex::scoped_lock lock(mutex_);
> shutdown_ = true;
> lock.unlock();
>
> op_queue<operation> ops;
>
> while (descriptor_state* state = registered_descriptors_.first())
> {
> for (int i = 0; i < max_ops; ++i)
> ops.push(state->op_queue_[i]);
> state->shutdown_ = true;
> registered_descriptors_.free(state);
> }
>
> timer_queues_.get_all_timers(ops);
>
> io_service_.abandon_operations(ops);
>}
>
>void epoll_reactor::fork_service(boost::asio::io_service::fork_event fork_ev)
>{
> if (fork_ev == boost::asio::io_service::fork_child)
> {
> if (epoll_fd_ != -1)
> ::close(epoll_fd_);
> epoll_fd_ = -1;
> epoll_fd_ = do_epoll_create();
>
> if (timer_fd_ != -1)
> ::close(timer_fd_);
> timer_fd_ = -1;
> timer_fd_ = do_timerfd_create();
>
> interrupter_.recreate();
>
>
> epoll_event ev = { 0, { 0 } };
> ev.events = EPOLLIN | EPOLLERR | EPOLLET;
> ev.data.ptr = &interrupter_;
> epoll_ctl(epoll_fd_, 1, interrupter_.read_descriptor(), &ev);
> interrupter_.interrupt();
>
>
> if (timer_fd_ != -1)
> {
> ev.events = EPOLLIN | EPOLLERR;
> ev.data.ptr = &timer_fd_;
> epoll_ctl(epoll_fd_, 1, timer_fd_, &ev);
> }
>
> update_timeout();
>
>
> mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
> for (descriptor_state* state = registered_descriptors_.first();
> state != 0; state = state->next_)
> {
> ev.events = state->registered_events_;
> ev.data.ptr = state;
> int result = epoll_ctl(epoll_fd_, 1, state->descriptor_, &ev);
> if (result != 0)
> {
> boost::system::error_code ec((*__errno_location ()),
> boost::asio::error::get_system_category());
> boost::asio::detail::throw_error(ec, "epoll re-registration");
> }
> }
> }
>}
>
>void epoll_reactor::init_task()
>{
> io_service_.init_task();
>}
>
>int epoll_reactor::register_descriptor(socket_type descriptor,
> epoll_reactor::per_descriptor_data& descriptor_data)
>{
> descriptor_data = allocate_descriptor_state();
>
> {
> mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
>
> descriptor_data->reactor_ = this;
> descriptor_data->descriptor_ = descriptor;
> descriptor_data->shutdown_ = false;
> }
>
> epoll_event ev = { 0, { 0 } };
> ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLPRI | EPOLLET;
> descriptor_data->registered_events_ = ev.events;
> ev.data.ptr = descriptor_data;
> int result = epoll_ctl(epoll_fd_, 1, descriptor, &ev);
> if (result != 0)
> return (*__errno_location ());
>
> return 0;
>}
>
>int epoll_reactor::register_internal_descriptor(
> int op_type, socket_type descriptor,
> epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op)
>{
> descriptor_data = allocate_descriptor_state();
>
> {
> mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
>
> descriptor_data->reactor_ = this;
> descriptor_data->descriptor_ = descriptor;
> descriptor_data->shutdown_ = false;
> descriptor_data->op_queue_[op_type].push(op);
> }
>
> epoll_event ev = { 0, { 0 } };
> ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLPRI | EPOLLET;
> descriptor_data->registered_events_ = ev.events;
> ev.data.ptr = descriptor_data;
> int result = epoll_ctl(epoll_fd_, 1, descriptor, &ev);
> if (result != 0)
> return (*__errno_location ());
>
> return 0;
>}
>
>void epoll_reactor::move_descriptor(socket_type,
> epoll_reactor::per_descriptor_data& target_descriptor_data,
> epoll_reactor::per_descriptor_data& source_descriptor_data)
>{
> target_descriptor_data = source_descriptor_data;
> source_descriptor_data = 0;
>}
>
>void epoll_reactor::start_op(int op_type, socket_type descriptor,
> epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op,
> bool is_continuation, bool allow_speculative)
>{
> if (!descriptor_data)
> {
> op->ec_ = boost::asio::error::bad_descriptor;
> post_immediate_completion(op, is_continuation);
> return;
> }
>
> mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
>
> if (descriptor_data->shutdown_)
> {
> post_immediate_completion(op, is_continuation);
> return;
> }
>
> if (descriptor_data->op_queue_[op_type].empty())
> {
> if (allow_speculative
> && (op_type != read_op
> || descriptor_data->op_queue_[except_op].empty()))
> {
> if (op->perform())
> {
> descriptor_lock.unlock();
> io_service_.post_immediate_completion(op, is_continuation);
> return;
> }
>
> if (op_type == write_op)
> {
> if ((descriptor_data->registered_events_ & EPOLLOUT) == 0)
> {
> epoll_event ev = { 0, { 0 } };
> ev.events = descriptor_data->registered_events_ | EPOLLOUT;
> ev.data.ptr = descriptor_data;
> if (epoll_ctl(epoll_fd_, 3, descriptor, &ev) == 0)
> {
> descriptor_data->registered_events_ |= ev.events;
> }
> else
> {
> op->ec_ = boost::system::error_code((*__errno_location ()),
> boost::asio::error::get_system_category());
> io_service_.post_immediate_completion(op, is_continuation);
> return;
> }
> }
> }
> }
> else
> {
> if (op_type == write_op)
> {
> descriptor_data->registered_events_ |= EPOLLOUT;
> }
>
> epoll_event ev = { 0, { 0 } };
> ev.events = descriptor_data->registered_events_;
> ev.data.ptr = descriptor_data;
> epoll_ctl(epoll_fd_, 3, descriptor, &ev);
> }
> }
>
> descriptor_data->op_queue_[op_type].push(op);
> io_service_.work_started();
>}
>
>void epoll_reactor::cancel_ops(socket_type,
> epoll_reactor::per_descriptor_data& descriptor_data)
>{
> if (!descriptor_data)
> return;
>
> mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
>
> op_queue<operation> ops;
> for (int i = 0; i < max_ops; ++i)
> {
> while (reactor_op* op = descriptor_data->op_queue_[i].front())
> {
> op->ec_ = boost::asio::error::operation_aborted;
> descriptor_data->op_queue_[i].pop();
> ops.push(op);
> }
> }
>
> descriptor_lock.unlock();
>
> io_service_.post_deferred_completions(ops);
>}
>
>void epoll_reactor::deregister_descriptor(socket_type descriptor,
> epoll_reactor::per_descriptor_data& descriptor_data, bool closing)
>{
> if (!descriptor_data)
> return;
>
> mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
>
> if (!descriptor_data->shutdown_)
> {
> if (closing)
> {
>
>
> }
> else
> {
> epoll_event ev = { 0, { 0 } };
> epoll_ctl(epoll_fd_, 2, descriptor, &ev);
> }
>
> op_queue<operation> ops;
> for (int i = 0; i < max_ops; ++i)
> {
> while (reactor_op* op = descriptor_data->op_queue_[i].front())
> {
> op->ec_ = boost::asio::error::operation_aborted;
> descriptor_data->op_queue_[i].pop();
> ops.push(op);
> }
> }
>
> descriptor_data->descriptor_ = -1;
> descriptor_data->shutdown_ = true;
>
> descriptor_lock.unlock();
>
> free_descriptor_state(descriptor_data);
> descriptor_data = 0;
>
> io_service_.post_deferred_completions(ops);
> }
>}
>
>void epoll_reactor::deregister_internal_descriptor(socket_type descriptor,
> epoll_reactor::per_descriptor_data& descriptor_data)
>{
> if (!descriptor_data)
> return;
>
> mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
>
> if (!descriptor_data->shutdown_)
> {
> epoll_event ev = { 0, { 0 } };
> epoll_ctl(epoll_fd_, 2, descriptor, &ev);
>
> op_queue<operation> ops;
> for (int i = 0; i < max_ops; ++i)
> ops.push(descriptor_data->op_queue_[i]);
>
> descriptor_data->descriptor_ = -1;
> descriptor_data->shutdown_ = true;
>
> descriptor_lock.unlock();
>
> free_descriptor_state(descriptor_data);
> descriptor_data = 0;
> }
>}
>
>void epoll_reactor::run(bool block, op_queue<operation>& ops)
>{
>
>
>
>
>
>
>
> int timeout;
> if (timer_fd_ != -1)
> timeout = block ? -1 : 0;
> else
> {
> mutex::scoped_lock lock(mutex_);
> timeout = block ? get_timeout() : 0;
> }
>
>
> epoll_event events[128];
> int num_events = epoll_wait(epoll_fd_, events, 128, timeout);
>
>
> bool check_timers = (timer_fd_ == -1);
>
>
>
>
>
> for (int i = 0; i < num_events; ++i)
> {
> void* ptr = events[i].data.ptr;
> if (ptr == &interrupter_)
> {
>
>
>
>
>
>
> if (timer_fd_ == -1)
> check_timers = true;
>
>
>
> }
>
> else if (ptr == &timer_fd_)
> {
> check_timers = true;
> }
>
> else
> {
>
>
>
> descriptor_state* descriptor_data = static_cast<descriptor_state*>(ptr);
> descriptor_data->set_ready_events(events[i].events);
> ops.push(descriptor_data);
> }
> }
>
> if (check_timers)
> {
> mutex::scoped_lock common_lock(mutex_);
> timer_queues_.get_ready_timers(ops);
>
>
> if (timer_fd_ != -1)
> {
> itimerspec new_timeout;
> itimerspec old_timeout;
> int flags = get_timeout(new_timeout);
> timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
> }
>
> }
>}
>
>void epoll_reactor::interrupt()
>{
> epoll_event ev = { 0, { 0 } };
> ev.events = EPOLLIN | EPOLLERR | EPOLLET;
> ev.data.ptr = &interrupter_;
> epoll_ctl(epoll_fd_, 3, interrupter_.read_descriptor(), &ev);
>}
>
>int epoll_reactor::do_epoll_create()
>{
>
> int fd = epoll_create1(EPOLL_CLOEXEC);
>
>
>
>
>
> if (fd == -1 && ((*__errno_location ()) == 22 || (*__errno_location ()) == 38))
> {
> fd = epoll_create(epoll_size);
> if (fd != -1)
> ::fcntl(fd, 2, 1);
> }
>
> if (fd == -1)
> {
> boost::system::error_code ec((*__errno_location ()),
> boost::asio::error::get_system_category());
> boost::asio::detail::throw_error(ec, "epoll");
> }
>
> return fd;
>}
>
>int epoll_reactor::do_timerfd_create()
>{
>
>
> int fd = timerfd_create(1, TFD_CLOEXEC);
>
>
>
>
>
> if (fd == -1 && (*__errno_location ()) == 22)
> {
> fd = timerfd_create(1, 0);
> if (fd != -1)
> ::fcntl(fd, 2, 1);
> }
>
> return fd;
>
>
>
>}
>
>epoll_reactor::descriptor_state* epoll_reactor::allocate_descriptor_state()
>{
> mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
> return registered_descriptors_.alloc();
>}
>
>void epoll_reactor::free_descriptor_state(epoll_reactor::descriptor_state* s)
>{
> mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
> registered_descriptors_.free(s);
>}
>
>void epoll_reactor::do_add_timer_queue(timer_queue_base& queue)
>{
> mutex::scoped_lock lock(mutex_);
> timer_queues_.insert(&queue);
>}
>
>void epoll_reactor::do_remove_timer_queue(timer_queue_base& queue)
>{
> mutex::scoped_lock lock(mutex_);
> timer_queues_.erase(&queue);
>}
>
>void epoll_reactor::update_timeout()
>{
>
> if (timer_fd_ != -1)
> {
> itimerspec new_timeout;
> itimerspec old_timeout;
> int flags = get_timeout(new_timeout);
> timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
> return;
> }
>
> interrupt();
>}
>
>int epoll_reactor::get_timeout()
>{
>
>
> return timer_queues_.wait_duration_msec(5 * 60 * 1000);
>}
>
>
>int epoll_reactor::get_timeout(itimerspec& ts)
>{
> ts.it_interval.tv_sec = 0;
> ts.it_interval.tv_nsec = 0;
>
> long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
> ts.it_value.tv_sec = usec / 1000000;
> ts.it_value.tv_nsec = usec ? (usec % 1000000) * 1000 : 1;
>
> return usec ? 0 : TFD_TIMER_ABSTIME;
>}
>
>
>struct epoll_reactor::perform_io_cleanup_on_block_exit
>{
> explicit perform_io_cleanup_on_block_exit(epoll_reactor* r)
> : reactor_(r), first_op_(0)
> {
> }
>
> ~perform_io_cleanup_on_block_exit()
> {
> if (first_op_)
> {
>
> if (!ops_.empty())
> reactor_->io_service_.post_deferred_completions(ops_);
>
>
>
>
>
> }
> else
> {
>
>
>
> reactor_->io_service_.work_started();
> }
> }
>
> epoll_reactor* reactor_;
> op_queue<operation> ops_;
> operation* first_op_;
>};
>
>epoll_reactor::descriptor_state::descriptor_state()
> : operation(&epoll_reactor::descriptor_state::do_complete)
>{
>}
>
>operation* epoll_reactor::descriptor_state::perform_io(uint32_t events)
>{
> mutex_.lock();
> perform_io_cleanup_on_block_exit io_cleanup(reactor_);
> mutex::scoped_lock descriptor_lock(mutex_, mutex::scoped_lock::adopt_lock);
>
>
>
> static const int flag[max_ops] = { EPOLLIN, EPOLLOUT, EPOLLPRI };
> for (int j = max_ops - 1; j >= 0; --j)
> {
> if (events & (flag[j] | EPOLLERR | EPOLLHUP))
> {
> while (reactor_op* op = op_queue_[j].front())
> {
> if (op->perform())
> {
> op_queue_[j].pop();
> io_cleanup.ops_.push(op);
> }
> else
> break;
> }
> }
> }
>
>
>
> io_cleanup.first_op_ = io_cleanup.ops_.front();
> io_cleanup.ops_.pop();
> return io_cleanup.first_op_;
>}
>
>void epoll_reactor::descriptor_state::do_complete(
> io_service_impl* owner, operation* base,
> const boost::system::error_code& ec, std::size_t bytes_transferred)
>{
> if (owner)
> {
> descriptor_state* descriptor_data = static_cast<descriptor_state*>(base);
> uint32_t events = static_cast<uint32_t>(bytes_transferred);
> if (operation* op = descriptor_data->perform_io(events))
> {
> op->complete(*owner, ec, 0);
> }
> }
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 661 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 2 3 4
># 242 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
># 22 "/usr/include/boost/asio/detail/reactor.hpp" 2 3 4
># 25 "/usr/include/boost/asio/detail/impl/task_io_service.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/task_io_service.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/impl/task_io_service.ipp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 29 "/usr/include/boost/asio/detail/impl/task_io_service.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>struct task_io_service::task_cleanup
>{
> ~task_cleanup()
> {
> if (this_thread_->private_outstanding_work > 0)
> {
> boost::asio::detail::increment(
> task_io_service_->outstanding_work_,
> this_thread_->private_outstanding_work);
> }
> this_thread_->private_outstanding_work = 0;
>
>
>
> lock_->lock();
> task_io_service_->task_interrupted_ = true;
> task_io_service_->op_queue_.push(this_thread_->private_op_queue);
> task_io_service_->op_queue_.push(&task_io_service_->task_operation_);
> }
>
> task_io_service* task_io_service_;
> mutex::scoped_lock* lock_;
> thread_info* this_thread_;
>};
>
>struct task_io_service::work_cleanup
>{
> ~work_cleanup()
> {
> if (this_thread_->private_outstanding_work > 1)
> {
> boost::asio::detail::increment(
> task_io_service_->outstanding_work_,
> this_thread_->private_outstanding_work - 1);
> }
> else if (this_thread_->private_outstanding_work < 1)
> {
> task_io_service_->work_finished();
> }
> this_thread_->private_outstanding_work = 0;
>
>
> if (!this_thread_->private_op_queue.empty())
> {
> lock_->lock();
> task_io_service_->op_queue_.push(this_thread_->private_op_queue);
> }
>
> }
>
> task_io_service* task_io_service_;
> mutex::scoped_lock* lock_;
> thread_info* this_thread_;
>};
>
>task_io_service::task_io_service(
> boost::asio::io_service& io_service, std::size_t concurrency_hint)
> : boost::asio::detail::service_base<task_io_service>(io_service),
> one_thread_(concurrency_hint == 1),
> mutex_(),
> task_(0),
> task_interrupted_(true),
> outstanding_work_(0),
> stopped_(false),
> shutdown_(false),
> first_idle_thread_(0)
>{
> (void)0;
>}
>
>void task_io_service::shutdown_service()
>{
> mutex::scoped_lock lock(mutex_);
> shutdown_ = true;
> lock.unlock();
>
>
> while (!op_queue_.empty())
> {
> operation* o = op_queue_.front();
> op_queue_.pop();
> if (o != &task_operation_)
> o->destroy();
> }
>
>
> task_ = 0;
>}
>
>void task_io_service::init_task()
>{
> mutex::scoped_lock lock(mutex_);
> if (!shutdown_ && !task_)
> {
> task_ = &use_service<reactor>(this->get_io_service());
> op_queue_.push(&task_operation_);
> wake_one_thread_and_unlock(lock);
> }
>}
>
>std::size_t task_io_service::run(boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> if (outstanding_work_ == 0)
> {
> stop();
> return 0;
> }
>
> thread_info this_thread;
> event wakeup_event;
> this_thread.wakeup_event = &wakeup_event;
> this_thread.private_outstanding_work = 0;
> this_thread.next = 0;
> thread_call_stack::context ctx(this, this_thread);
>
> mutex::scoped_lock lock(mutex_);
>
> std::size_t n = 0;
> for (; do_run_one(lock, this_thread, ec); lock.lock())
> if (n != (std::numeric_limits<std::size_t>::max)())
> ++n;
> return n;
>}
>
>std::size_t task_io_service::run_one(boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> if (outstanding_work_ == 0)
> {
> stop();
> return 0;
> }
>
> thread_info this_thread;
> event wakeup_event;
> this_thread.wakeup_event = &wakeup_event;
> this_thread.private_outstanding_work = 0;
> this_thread.next = 0;
> thread_call_stack::context ctx(this, this_thread);
>
> mutex::scoped_lock lock(mutex_);
>
> return do_run_one(lock, this_thread, ec);
>}
>
>std::size_t task_io_service::poll(boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> if (outstanding_work_ == 0)
> {
> stop();
> return 0;
> }
>
> thread_info this_thread;
> this_thread.wakeup_event = 0;
> this_thread.private_outstanding_work = 0;
> this_thread.next = 0;
> thread_call_stack::context ctx(this, this_thread);
>
> mutex::scoped_lock lock(mutex_);
>
>
>
>
>
> if (one_thread_)
> if (thread_info* outer_thread_info = ctx.next_by_key())
> op_queue_.push(outer_thread_info->private_op_queue);
>
>
> std::size_t n = 0;
> for (; do_poll_one(lock, this_thread, ec); lock.lock())
> if (n != (std::numeric_limits<std::size_t>::max)())
> ++n;
> return n;
>}
>
>std::size_t task_io_service::poll_one(boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> if (outstanding_work_ == 0)
> {
> stop();
> return 0;
> }
>
> thread_info this_thread;
> this_thread.wakeup_event = 0;
> this_thread.private_outstanding_work = 0;
> this_thread.next = 0;
> thread_call_stack::context ctx(this, this_thread);
>
> mutex::scoped_lock lock(mutex_);
>
>
>
>
>
> if (one_thread_)
> if (thread_info* outer_thread_info = ctx.next_by_key())
> op_queue_.push(outer_thread_info->private_op_queue);
>
>
> return do_poll_one(lock, this_thread, ec);
>}
>
>void task_io_service::stop()
>{
> mutex::scoped_lock lock(mutex_);
> stop_all_threads(lock);
>}
>
>bool task_io_service::stopped() const
>{
> mutex::scoped_lock lock(mutex_);
> return stopped_;
>}
>
>void task_io_service::reset()
>{
> mutex::scoped_lock lock(mutex_);
> stopped_ = false;
>}
>
>void task_io_service::post_immediate_completion(
> task_io_service::operation* op, bool is_continuation)
>{
>
> if (one_thread_ || is_continuation)
> {
> if (thread_info* this_thread = thread_call_stack::contains(this))
> {
> ++this_thread->private_outstanding_work;
> this_thread->private_op_queue.push(op);
> return;
> }
> }
>
>
> work_started();
> mutex::scoped_lock lock(mutex_);
> op_queue_.push(op);
> wake_one_thread_and_unlock(lock);
>}
>
>void task_io_service::post_deferred_completion(task_io_service::operation* op)
>{
>
> if (one_thread_)
> {
> if (thread_info* this_thread = thread_call_stack::contains(this))
> {
> this_thread->private_op_queue.push(op);
> return;
> }
> }
>
>
> mutex::scoped_lock lock(mutex_);
> op_queue_.push(op);
> wake_one_thread_and_unlock(lock);
>}
>
>void task_io_service::post_deferred_completions(
> op_queue<task_io_service::operation>& ops)
>{
> if (!ops.empty())
> {
>
> if (one_thread_)
> {
> if (thread_info* this_thread = thread_call_stack::contains(this))
> {
> this_thread->private_op_queue.push(ops);
> return;
> }
> }
>
>
> mutex::scoped_lock lock(mutex_);
> op_queue_.push(ops);
> wake_one_thread_and_unlock(lock);
> }
>}
>
>void task_io_service::do_dispatch(
> task_io_service::operation* op)
>{
> work_started();
> mutex::scoped_lock lock(mutex_);
> op_queue_.push(op);
> wake_one_thread_and_unlock(lock);
>}
>
>void task_io_service::abandon_operations(
> op_queue<task_io_service::operation>& ops)
>{
> op_queue<task_io_service::operation> ops2;
> ops2.push(ops);
>}
>
>std::size_t task_io_service::do_run_one(mutex::scoped_lock& lock,
> task_io_service::thread_info& this_thread,
> const boost::system::error_code& ec)
>{
> while (!stopped_)
> {
> if (!op_queue_.empty())
> {
>
> operation* o = op_queue_.front();
> op_queue_.pop();
> bool more_handlers = (!op_queue_.empty());
>
> if (o == &task_operation_)
> {
> task_interrupted_ = more_handlers;
>
> if (more_handlers && !one_thread_)
> {
> if (!wake_one_idle_thread_and_unlock(lock))
> lock.unlock();
> }
> else
> lock.unlock();
>
> task_cleanup on_exit = { this, &lock, &this_thread };
> (void)on_exit;
>
>
>
>
> task_->run(!more_handlers, this_thread.private_op_queue);
> }
> else
> {
> std::size_t task_result = o->task_result_;
>
> if (more_handlers && !one_thread_)
> wake_one_thread_and_unlock(lock);
> else
> lock.unlock();
>
>
> work_cleanup on_exit = { this, &lock, &this_thread };
> (void)on_exit;
>
>
> o->complete(*this, ec, task_result);
>
> return 1;
> }
> }
> else
> {
>
> this_thread.next = first_idle_thread_;
> first_idle_thread_ = &this_thread;
> this_thread.wakeup_event->clear(lock);
> this_thread.wakeup_event->wait(lock);
> }
> }
>
> return 0;
>}
>
>std::size_t task_io_service::do_poll_one(mutex::scoped_lock& lock,
> task_io_service::thread_info& this_thread,
> const boost::system::error_code& ec)
>{
> if (stopped_)
> return 0;
>
> operation* o = op_queue_.front();
> if (o == &task_operation_)
> {
> op_queue_.pop();
> lock.unlock();
>
> {
> task_cleanup c = { this, &lock, &this_thread };
> (void)c;
>
>
>
>
> task_->run(false, this_thread.private_op_queue);
> }
>
> o = op_queue_.front();
> if (o == &task_operation_)
> {
> wake_one_idle_thread_and_unlock(lock);
> return 0;
> }
> }
>
> if (o == 0)
> return 0;
>
> op_queue_.pop();
> bool more_handlers = (!op_queue_.empty());
>
> std::size_t task_result = o->task_result_;
>
> if (more_handlers && !one_thread_)
> wake_one_thread_and_unlock(lock);
> else
> lock.unlock();
>
>
> work_cleanup on_exit = { this, &lock, &this_thread };
> (void)on_exit;
>
>
> o->complete(*this, ec, task_result);
>
> return 1;
>}
>
>void task_io_service::stop_all_threads(
> mutex::scoped_lock& lock)
>{
> stopped_ = true;
>
> while (first_idle_thread_)
> {
> thread_info* idle_thread = first_idle_thread_;
> first_idle_thread_ = idle_thread->next;
> idle_thread->next = 0;
> idle_thread->wakeup_event->signal(lock);
> }
>
> if (!task_interrupted_ && task_)
> {
> task_interrupted_ = true;
> task_->interrupt();
> }
>}
>
>bool task_io_service::wake_one_idle_thread_and_unlock(
> mutex::scoped_lock& lock)
>{
> if (first_idle_thread_)
> {
> thread_info* idle_thread = first_idle_thread_;
> first_idle_thread_ = idle_thread->next;
> idle_thread->next = 0;
> idle_thread->wakeup_event->signal_and_unlock(lock);
> return true;
> }
> return false;
>}
>
>void task_io_service::wake_one_thread_and_unlock(
> mutex::scoped_lock& lock)
>{
> if (!wake_one_idle_thread_and_unlock(lock))
> {
> if (!task_interrupted_ && task_)
> {
> task_interrupted_ = true;
> task_->interrupt();
> }
> lock.unlock();
> }
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 509 "/usr/include/boost/asio/detail/impl/task_io_service.ipp" 2 3 4
># 203 "/usr/include/boost/asio/detail/task_io_service.hpp" 2 3 4
># 72 "/usr/include/boost/asio/impl/io_service.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 75 "/usr/include/boost/asio/impl/io_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>template <typename CompletionHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
>io_service::dispatch(CompletionHandler&& handler)
>{
>
>
> typedef typename handler_type<CompletionHandler, void()>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::zero_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), 0)) == 1, "CompletionHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()(), char(0))> type_check;
>
> detail::async_result_init<
> CompletionHandler, void ()> init(
> static_cast<CompletionHandler&&>(handler));
>
> impl_.dispatch(init.handler);
>
> return init.result.get();
>}
>
>template <typename CompletionHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
>io_service::post(CompletionHandler&& handler)
>{
>
>
> typedef typename handler_type<CompletionHandler, void()>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::zero_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), 0)) == 1, "CompletionHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()(), char(0))> type_check;
>
> detail::async_result_init<
> CompletionHandler, void ()> init(
> static_cast<CompletionHandler&&>(handler));
>
> impl_.post(init.handler);
>
> return init.result.get();
>}
>
>template <typename Handler>
>
>
>
>inline detail::wrapped_handler<io_service&, Handler>
>
>io_service::wrap(Handler handler)
>{
> return detail::wrapped_handler<io_service&, Handler>(*this, handler);
>}
>
>inline io_service::work::work(boost::asio::io_service& io_service)
> : io_service_impl_(io_service.impl_)
>{
> io_service_impl_.work_started();
>}
>
>inline io_service::work::work(const work& other)
> : io_service_impl_(other.io_service_impl_)
>{
> io_service_impl_.work_started();
>}
>
>inline io_service::work::~work()
>{
> io_service_impl_.work_finished();
>}
>
>inline boost::asio::io_service& io_service::work::get_io_service()
>{
> return io_service_impl_.get_io_service();
>}
>
>inline boost::asio::io_service& io_service::service::get_io_service()
>{
> return owner_;
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 155 "/usr/include/boost/asio/impl/io_service.hpp" 2 3 4
># 771 "/usr/include/boost/asio/io_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/io_service.ipp" 1 3 4
># 21 "/usr/include/boost/asio/impl/io_service.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/scoped_ptr.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/scoped_ptr.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/scoped_ptr.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename T>
>class scoped_ptr
>{
>public:
>
> explicit scoped_ptr(T* p = 0)
> : p_(p)
> {
> }
>
>
> ~scoped_ptr()
> {
> delete p_;
> }
>
>
> T* get()
> {
> return p_;
> }
>
>
> T* operator->()
> {
> return p_;
> }
>
>
> T& operator*()
> {
> return *p_;
> }
>
>
> void reset(T* p = 0)
> {
> delete p_;
> p_ = p;
> }
>
>private:
>
> scoped_ptr(const scoped_ptr&);
> scoped_ptr& operator=(const scoped_ptr&);
>
> T* p_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 80 "/usr/include/boost/asio/detail/scoped_ptr.hpp" 2 3 4
># 22 "/usr/include/boost/asio/impl/io_service.ipp" 2 3 4
># 31 "/usr/include/boost/asio/impl/io_service.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 32 "/usr/include/boost/asio/impl/io_service.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>io_service::io_service()
> : service_registry_(new boost::asio::detail::service_registry(
> *this, static_cast<impl_type*>(0),
> (std::numeric_limits<std::size_t>::max)())),
> impl_(service_registry_->first_service<impl_type>())
>{
>}
>
>io_service::io_service(std::size_t concurrency_hint)
> : service_registry_(new boost::asio::detail::service_registry(
> *this, static_cast<impl_type*>(0), concurrency_hint)),
> impl_(service_registry_->first_service<impl_type>())
>{
>}
>
>io_service::~io_service()
>{
> delete service_registry_;
>}
>
>std::size_t io_service::run()
>{
> boost::system::error_code ec;
> std::size_t s = impl_.run(ec);
> boost::asio::detail::throw_error(ec);
> return s;
>}
>
>std::size_t io_service::run(boost::system::error_code& ec)
>{
> return impl_.run(ec);
>}
>
>std::size_t io_service::run_one()
>{
> boost::system::error_code ec;
> std::size_t s = impl_.run_one(ec);
> boost::asio::detail::throw_error(ec);
> return s;
>}
>
>std::size_t io_service::run_one(boost::system::error_code& ec)
>{
> return impl_.run_one(ec);
>}
>
>std::size_t io_service::poll()
>{
> boost::system::error_code ec;
> std::size_t s = impl_.poll(ec);
> boost::asio::detail::throw_error(ec);
> return s;
>}
>
>std::size_t io_service::poll(boost::system::error_code& ec)
>{
> return impl_.poll(ec);
>}
>
>std::size_t io_service::poll_one()
>{
> boost::system::error_code ec;
> std::size_t s = impl_.poll_one(ec);
> boost::asio::detail::throw_error(ec);
> return s;
>}
>
>std::size_t io_service::poll_one(boost::system::error_code& ec)
>{
> return impl_.poll_one(ec);
>}
>
>void io_service::stop()
>{
> impl_.stop();
>}
>
>bool io_service::stopped() const
>{
> return impl_.stopped();
>}
>
>void io_service::reset()
>{
> impl_.reset();
>}
>
>void io_service::notify_fork(boost::asio::io_service::fork_event event)
>{
> service_registry_->notify_fork(event);
>}
>
>io_service::service::service(boost::asio::io_service& owner)
> : owner_(owner),
> next_(0)
>{
>}
>
>io_service::service::~service()
>{
>}
>
>void io_service::service::fork_service(boost::asio::io_service::fork_event)
>{
>}
>
>service_already_exists::service_already_exists()
> : std::logic_error("Service already exists.")
>{
>}
>
>invalid_service_owner::invalid_service_owner()
> : std::logic_error("Invalid service owner.")
>{
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 156 "/usr/include/boost/asio/impl/io_service.ipp" 2 3 4
># 773 "/usr/include/boost/asio/io_service.hpp" 2 3 4
># 20 "/usr/include/boost/asio/basic_io_object.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/basic_io_object.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>namespace detail
>{
>
> template <typename IoObjectService>
> class service_has_move
> {
> private:
> typedef IoObjectService service_type;
> typedef typename service_type::implementation_type implementation_type;
>
> template <typename T, typename U>
> static auto eval(T* t, U* u) -> decltype(t->move_construct(*u, *u), char());
> static char (&eval(...))[2];
>
> public:
> static const bool value =
> sizeof(service_has_move::eval(
> static_cast<service_type*>(0),
> static_cast<implementation_type*>(0))) == 1;
> };
>}
># 58 "/usr/include/boost/asio/basic_io_object.hpp" 3 4
>template <typename IoObjectService,
> bool Movable = detail::service_has_move<IoObjectService>::value>
>
>class basic_io_object
>{
>public:
>
> typedef IoObjectService service_type;
>
>
> typedef typename service_type::implementation_type implementation_type;
># 78 "/usr/include/boost/asio/basic_io_object.hpp" 3 4
> boost::asio::io_service& get_io_service()
> {
> return service.get_io_service();
> }
>
>protected:
>
>
>
>
>
> explicit basic_io_object(boost::asio::io_service& io_service)
> : service(boost::asio::use_service<IoObjectService>(io_service))
> {
> service.construct(implementation);
> }
># 122 "/usr/include/boost/asio/basic_io_object.hpp" 3 4
> ~basic_io_object()
> {
> service.destroy(implementation);
> }
>
>
> service_type& get_service()
> {
> return service;
> }
>
>
> const service_type& get_service() const
> {
> return service;
> }
>
>
>
>
>
>
> service_type& service;
>
>
> implementation_type& get_implementation()
> {
> return implementation;
> }
>
>
> const implementation_type& get_implementation() const
> {
> return implementation;
> }
>
>
>
> implementation_type implementation;
>
>private:
> basic_io_object(const basic_io_object&);
> basic_io_object& operator=(const basic_io_object&);
>};
>
>
>
>template <typename IoObjectService>
>class basic_io_object<IoObjectService, true>
>{
>public:
> typedef IoObjectService service_type;
> typedef typename service_type::implementation_type implementation_type;
>
> boost::asio::io_service& get_io_service()
> {
> return service_->get_io_service();
> }
>
>protected:
> explicit basic_io_object(boost::asio::io_service& io_service)
> : service_(&boost::asio::use_service<IoObjectService>(io_service))
> {
> service_->construct(implementation);
> }
>
> basic_io_object(basic_io_object&& other)
> : service_(&other.get_service())
> {
> service_->move_construct(implementation, other.implementation);
> }
>
> ~basic_io_object()
> {
> service_->destroy(implementation);
> }
>
> basic_io_object& operator=(basic_io_object&& other)
> {
> service_->move_assign(implementation,
> *other.service_, other.implementation);
> service_ = other.service_;
> return *this;
> }
>
> service_type& get_service()
> {
> return *service_;
> }
>
> const service_type& get_service() const
> {
> return *service_;
> }
>
> implementation_type& get_implementation()
> {
> return implementation;
> }
>
> const implementation_type& get_implementation() const
> {
> return implementation;
> }
>
> implementation_type implementation;
>
>private:
> basic_io_object(const basic_io_object&);
> void operator=(const basic_io_object&);
>
> IoObjectService* service_;
>};
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 241 "/usr/include/boost/asio/basic_io_object.hpp" 2 3 4
># 21 "/usr/include/boost/asio/basic_socket.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/type_traits.hpp" 1 3 4
># 33 "/usr/include/boost/asio/detail/type_traits.hpp" 3 4
>namespace boost {
>namespace asio {
>
>
>using std::add_const;
>using std::enable_if;
>using std::is_const;
>using std::is_convertible;
>using std::is_function;
>using std::is_same;
>using std::remove_pointer;
>using std::remove_reference;
># 57 "/usr/include/boost/asio/detail/type_traits.hpp" 3 4
>}
>}
># 24 "/usr/include/boost/asio/basic_socket.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/socket_base.hpp" 1 3 4
># 19 "/usr/include/boost/asio/socket_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/io_control.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/io_control.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/detail/io_control.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/io_control.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>namespace io_control {
>
>
>class non_blocking_io
>{
>public:
>
> non_blocking_io()
> : value_(0)
> {
> }
>
>
> non_blocking_io(bool value)
> : value_(value ? 1 : 0)
> {
> }
>
>
> int name() const
> {
> return static_cast<int>(0x5421);
> }
>
>
> void set(bool value)
> {
> value_ = value ? 1 : 0;
> }
>
>
> bool get() const
> {
> return value_ != 0;
> }
>
>
> detail::ioctl_arg_type* data()
> {
> return &value_;
> }
>
>
> const detail::ioctl_arg_type* data() const
> {
> return &value_;
> }
>
>private:
> detail::ioctl_arg_type value_;
>};
>
>
>class bytes_readable
>{
>public:
>
> bytes_readable()
> : value_(0)
> {
> }
>
>
> bytes_readable(std::size_t value)
> : value_(static_cast<detail::ioctl_arg_type>(value))
> {
> }
>
>
> int name() const
> {
> return static_cast<int>(0x541B);
> }
>
>
> void set(std::size_t value)
> {
> value_ = static_cast<detail::ioctl_arg_type>(value);
> }
>
>
> std::size_t get() const
> {
> return static_cast<std::size_t>(value_);
> }
>
>
> detail::ioctl_arg_type* data()
> {
> return &value_;
> }
>
>
> const detail::ioctl_arg_type* data() const
> {
> return &value_;
> }
>
>private:
> detail::ioctl_arg_type value_;
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 135 "/usr/include/boost/asio/detail/io_control.hpp" 2 3 4
># 20 "/usr/include/boost/asio/socket_base.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/socket_option.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/socket_option.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/detail/socket_option.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/socket_option.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>namespace socket_option {
>
>
>template <int Level, int Name>
>class boolean
>{
>public:
>
> boolean()
> : value_(0)
> {
> }
>
>
> explicit boolean(bool v)
> : value_(v ? 1 : 0)
> {
> }
>
>
> boolean& operator=(bool v)
> {
> value_ = v ? 1 : 0;
> return *this;
> }
>
>
> bool value() const
> {
> return !!value_;
> }
>
>
> operator bool() const
> {
> return !!value_;
> }
>
>
> bool operator!() const
> {
> return !value_;
> }
>
>
> template <typename Protocol>
> int level(const Protocol&) const
> {
> return Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol&) const
> {
> return Name;
> }
>
>
> template <typename Protocol>
> int* data(const Protocol&)
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> const int* data(const Protocol&) const
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol&) const
> {
> return sizeof(value_);
> }
>
>
> template <typename Protocol>
> void resize(const Protocol&, std::size_t s)
> {
>
>
>
> switch (s)
> {
> case sizeof(char):
> value_ = *reinterpret_cast<char*>(&value_) ? 1 : 0;
> break;
> case sizeof(value_):
> break;
> default:
> {
> std::length_error ex("boolean socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
> }
> }
>
>private:
> int value_;
>};
>
>
>template <int Level, int Name>
>class integer
>{
>public:
>
> integer()
> : value_(0)
> {
> }
>
>
> explicit integer(int v)
> : value_(v)
> {
> }
>
>
> integer& operator=(int v)
> {
> value_ = v;
> return *this;
> }
>
>
> int value() const
> {
> return value_;
> }
>
>
> template <typename Protocol>
> int level(const Protocol&) const
> {
> return Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol&) const
> {
> return Name;
> }
>
>
> template <typename Protocol>
> int* data(const Protocol&)
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> const int* data(const Protocol&) const
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol&) const
> {
> return sizeof(value_);
> }
>
>
> template <typename Protocol>
> void resize(const Protocol&, std::size_t s)
> {
> if (s != sizeof(value_))
> {
> std::length_error ex("integer socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
> }
>
>private:
> int value_;
>};
>
>
>template <int Level, int Name>
>class linger
>{
>public:
>
> linger()
> {
> value_.l_onoff = 0;
> value_.l_linger = 0;
> }
>
>
> linger(bool e, int t)
> {
> enabled(e);
> timeout (t);
> }
>
>
> void enabled(bool value)
> {
> value_.l_onoff = value ? 1 : 0;
> }
>
>
> bool enabled() const
> {
> return value_.l_onoff != 0;
> }
>
>
> void timeout (int value)
> {
>
>
>
> value_.l_linger = value;
>
> }
>
>
> int timeout () const
> {
> return static_cast<int>(value_.l_linger);
> }
>
>
> template <typename Protocol>
> int level(const Protocol&) const
> {
> return Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol&) const
> {
> return Name;
> }
>
>
> template <typename Protocol>
> ::linger* data(const Protocol&)
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> const ::linger* data(const Protocol&) const
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol&) const
> {
> return sizeof(value_);
> }
>
>
> template <typename Protocol>
> void resize(const Protocol&, std::size_t s)
> {
> if (s != sizeof(value_))
> {
> std::length_error ex("linger socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
> }
>
>private:
> ::linger value_;
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 317 "/usr/include/boost/asio/detail/socket_option.hpp" 2 3 4
># 21 "/usr/include/boost/asio/socket_base.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 24 "/usr/include/boost/asio/socket_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>
>
>class socket_base
>{
>public:
>
> enum shutdown_type
> {
># 47 "/usr/include/boost/asio/socket_base.hpp" 3 4
> shutdown_receive = boost::asio::detail::shutdown_receive,
> shutdown_send = boost::asio::detail::shutdown_send,
> shutdown_both = boost::asio::detail::shutdown_both
>
> };
>
>
> typedef int message_flags;
># 69 "/usr/include/boost/asio/socket_base.hpp" 3 4
> static const int message_peek = boost::asio::detail::message_peek
> ;
> static const int message_out_of_band = boost::asio::detail::message_out_of_band
> ;
> static const int message_do_not_route = boost::asio::detail::message_do_not_route
> ;
> static const int message_end_of_record = boost::asio::detail::message_end_of_record
> ;
># 108 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::boolean<
> 1, 6> broadcast;
># 141 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::boolean<
> 1, 1> debug;
># 174 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::boolean<
> 1, 5> do_not_route;
># 207 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::boolean<
> 1, 9> keep_alive;
># 240 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::integer<
> 1, 7> send_buffer_size;
># 273 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::integer<
> 1, 19> send_low_watermark;
># 306 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::integer<
> 1, 8> receive_buffer_size;
># 339 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::integer<
> 1, 18> receive_low_watermark;
># 373 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::boolean<
> 1, 2> reuse_address;
># 408 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::linger<
> 1, 13> linger;
># 443 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::boolean<
> boost::asio::detail::custom_socket_option_level,
> boost::asio::detail::enable_connection_aborted_option>
> enable_connection_aborted;
># 468 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::io_control::non_blocking_io non_blocking_io;
># 491 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::io_control::bytes_readable bytes_readable;
>
>
>
>
>
>
> static const int max_connections = 128;
>
>
>protected:
>
> ~socket_base()
> {
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 512 "/usr/include/boost/asio/socket_base.hpp" 2 3 4
># 26 "/usr/include/boost/asio/basic_socket.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/basic_socket.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 41 "/usr/include/boost/asio/basic_socket.hpp" 3 4
>template <typename Protocol, typename SocketService>
>class basic_socket
> : public basic_io_object<SocketService>,
> public socket_base
>{
>public:
>
>
> typedef typename SocketService::native_handle_type native_type;
>
>
> typedef typename SocketService::native_handle_type native_handle_type;
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
>
>
> typedef basic_socket<Protocol, SocketService> lowest_layer_type;
># 70 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> explicit basic_socket(boost::asio::io_service& io_service)
> : basic_io_object<SocketService>(io_service)
> {
> }
># 86 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> basic_socket(boost::asio::io_service& io_service,
> const protocol_type& protocol)
> : basic_io_object<SocketService>(io_service)
> {
> boost::system::error_code ec;
> this->get_service().open(this->get_implementation(), protocol, ec);
> boost::asio::detail::throw_error(ec, "open");
> }
># 110 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> basic_socket(boost::asio::io_service& io_service,
> const endpoint_type& endpoint)
> : basic_io_object<SocketService>(io_service)
> {
> boost::system::error_code ec;
> const protocol_type protocol = endpoint.protocol();
> this->get_service().open(this->get_implementation(), protocol, ec);
> boost::asio::detail::throw_error(ec, "open");
> this->get_service().bind(this->get_implementation(), endpoint, ec);
> boost::asio::detail::throw_error(ec, "bind");
> }
># 135 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> basic_socket(boost::asio::io_service& io_service,
> const protocol_type& protocol, const native_handle_type& native_socket)
> : basic_io_object<SocketService>(io_service)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> protocol, native_socket, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 156 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> basic_socket(basic_socket&& other)
> : basic_io_object<SocketService>(
> static_cast<basic_socket&&>(other))
> {
> }
># 172 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> basic_socket& operator=(basic_socket&& other)
> {
> basic_io_object<SocketService>::operator=(
> static_cast<basic_socket&&>(other));
> return *this;
> }
>
>
> template <typename Protocol1, typename SocketService1>
> friend class basic_socket;
># 193 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename Protocol1, typename SocketService1>
> basic_socket(basic_socket<Protocol1, SocketService1>&& other,
> typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
> : basic_io_object<SocketService>(other.get_io_service())
> {
> this->get_service().template converting_move_construct<Protocol1>(
> this->get_implementation(), other.get_implementation());
> }
># 212 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename Protocol1, typename SocketService1>
> typename enable_if<is_convertible<Protocol1, Protocol>::value,
> basic_socket>::type& operator=(
> basic_socket<Protocol1, SocketService1>&& other)
> {
> basic_socket tmp(static_cast<basic_socket< Protocol1, SocketService1>&&>
> (other));
> basic_io_object<SocketService>::operator=(
> static_cast<basic_socket&&>(tmp));
> return *this;
> }
># 234 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> lowest_layer_type& lowest_layer()
> {
> return *this;
> }
># 248 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> const lowest_layer_type& lowest_layer() const
> {
> return *this;
> }
># 267 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void open(const protocol_type& protocol = protocol_type())
> {
> boost::system::error_code ec;
> this->get_service().open(this->get_implementation(), protocol, ec);
> boost::asio::detail::throw_error(ec, "open");
> }
># 293 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code open(const protocol_type& protocol,
> boost::system::error_code& ec)
> {
> return this->get_service().open(this->get_implementation(), protocol, ec);
> }
># 309 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void assign(const protocol_type& protocol,
> const native_handle_type& native_socket)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> protocol, native_socket, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 328 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code assign(const protocol_type& protocol,
> const native_handle_type& native_socket, boost::system::error_code& ec)
> {
> return this->get_service().assign(this->get_implementation(),
> protocol, native_socket, ec);
> }
>
>
> bool is_open() const
> {
> return this->get_service().is_open(this->get_implementation());
> }
># 353 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void close()
> {
> boost::system::error_code ec;
> this->get_service().close(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "close");
> }
># 384 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code close(boost::system::error_code& ec)
> {
> return this->get_service().close(this->get_implementation(), ec);
> }
>
>
>
>
>
>
>
> native_type native()
> {
> return this->get_service().native_handle(this->get_implementation());
> }
>
>
>
>
>
>
>
> native_handle_type native_handle()
> {
> return this->get_service().native_handle(this->get_implementation());
> }
># 452 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void cancel()
> {
> boost::system::error_code ec;
> this->get_service().cancel(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "cancel");
> }
># 500 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code cancel(boost::system::error_code& ec)
> {
> return this->get_service().cancel(this->get_implementation(), ec);
> }
># 515 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> bool at_mark() const
> {
> boost::system::error_code ec;
> bool b = this->get_service().at_mark(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "at_mark");
> return b;
> }
># 533 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> bool at_mark(boost::system::error_code& ec) const
> {
> return this->get_service().at_mark(this->get_implementation(), ec);
> }
># 548 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> std::size_t available() const
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().available(
> this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "available");
> return s;
> }
># 567 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> std::size_t available(boost::system::error_code& ec) const
> {
> return this->get_service().available(this->get_implementation(), ec);
> }
># 590 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void bind(const endpoint_type& endpoint)
> {
> boost::system::error_code ec;
> this->get_service().bind(this->get_implementation(), endpoint, ec);
> boost::asio::detail::throw_error(ec, "bind");
> }
># 620 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code bind(const endpoint_type& endpoint,
> boost::system::error_code& ec)
> {
> return this->get_service().bind(this->get_implementation(), endpoint, ec);
> }
># 649 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void connect(const endpoint_type& peer_endpoint)
> {
> boost::system::error_code ec;
> if (!is_open())
> {
> this->get_service().open(this->get_implementation(),
> peer_endpoint.protocol(), ec);
> boost::asio::detail::throw_error(ec, "connect");
> }
> this->get_service().connect(this->get_implementation(), peer_endpoint, ec);
> boost::asio::detail::throw_error(ec, "connect");
> }
># 690 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code connect(const endpoint_type& peer_endpoint,
> boost::system::error_code& ec)
> {
> if (!is_open())
> {
> if (this->get_service().open(this->get_implementation(),
> peer_endpoint.protocol(), ec))
> {
> return ec;
> }
> }
>
> return this->get_service().connect(
> this->get_implementation(), peer_endpoint, ec);
> }
># 747 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename ConnectHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
>
> async_connect(const endpoint_type& peer_endpoint,
> ConnectHandler&& handler)
> {
>
>
> typedef typename handler_type<ConnectHandler, void(boost::system::error_code)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "ConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> type_check;
>
> if (!is_open())
> {
> boost::system::error_code ec;
> const protocol_type protocol = peer_endpoint.protocol();
> if (this->get_service().open(this->get_implementation(), protocol, ec))
> {
> detail::async_result_init<
> ConnectHandler, void (boost::system::error_code)> init(
> static_cast<ConnectHandler&&>(handler));
>
> this->get_io_service().post(
> boost::asio::detail::bind_handler(
> static_cast<typename handler_type<ConnectHandler, void (boost::system::error_code)>::type&&>
> (
> init.handler), ec));
>
> return init.result.get();
> }
> }
>
> return this->get_service().async_connect(this->get_implementation(),
> peer_endpoint, static_cast<ConnectHandler&&>(handler));
> }
># 815 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename SettableSocketOption>
> void set_option(const SettableSocketOption& option)
> {
> boost::system::error_code ec;
> this->get_service().set_option(this->get_implementation(), option, ec);
> boost::asio::detail::throw_error(ec, "set_option");
> }
># 862 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename SettableSocketOption>
> boost::system::error_code set_option(const SettableSocketOption& option,
> boost::system::error_code& ec)
> {
> return this->get_service().set_option(
> this->get_implementation(), option, ec);
> }
># 905 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename GettableSocketOption>
> void get_option(GettableSocketOption& option) const
> {
> boost::system::error_code ec;
> this->get_service().get_option(this->get_implementation(), option, ec);
> boost::asio::detail::throw_error(ec, "get_option");
> }
># 953 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename GettableSocketOption>
> boost::system::error_code get_option(GettableSocketOption& option,
> boost::system::error_code& ec) const
> {
> return this->get_service().get_option(
> this->get_implementation(), option, ec);
> }
># 983 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename IoControlCommand>
> void io_control(IoControlCommand& command)
> {
> boost::system::error_code ec;
> this->get_service().io_control(this->get_implementation(), command, ec);
> boost::asio::detail::throw_error(ec, "io_control");
> }
># 1018 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename IoControlCommand>
> boost::system::error_code io_control(IoControlCommand& command,
> boost::system::error_code& ec)
> {
> return this->get_service().io_control(
> this->get_implementation(), command, ec);
> }
># 1037 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> bool non_blocking() const
> {
> return this->get_service().non_blocking(this->get_implementation());
> }
># 1055 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void non_blocking(bool mode)
> {
> boost::system::error_code ec;
> this->get_service().non_blocking(this->get_implementation(), mode, ec);
> boost::asio::detail::throw_error(ec, "non_blocking");
> }
># 1075 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code non_blocking(
> bool mode, boost::system::error_code& ec)
> {
> return this->get_service().non_blocking(
> this->get_implementation(), mode, ec);
> }
># 1166 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> bool native_non_blocking() const
> {
> return this->get_service().native_non_blocking(this->get_implementation());
> }
># 1256 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void native_non_blocking(bool mode)
> {
> boost::system::error_code ec;
> this->get_service().native_non_blocking(
> this->get_implementation(), mode, ec);
> boost::asio::detail::throw_error(ec, "native_non_blocking");
> }
># 1349 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code native_non_blocking(
> bool mode, boost::system::error_code& ec)
> {
> return this->get_service().native_non_blocking(
> this->get_implementation(), mode, ec);
> }
># 1371 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> endpoint_type local_endpoint() const
> {
> boost::system::error_code ec;
> endpoint_type ep = this->get_service().local_endpoint(
> this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "local_endpoint");
> return ep;
> }
># 1401 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> endpoint_type local_endpoint(boost::system::error_code& ec) const
> {
> return this->get_service().local_endpoint(this->get_implementation(), ec);
> }
># 1421 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> endpoint_type remote_endpoint() const
> {
> boost::system::error_code ec;
> endpoint_type ep = this->get_service().remote_endpoint(
> this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "remote_endpoint");
> return ep;
> }
># 1451 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> endpoint_type remote_endpoint(boost::system::error_code& ec) const
> {
> return this->get_service().remote_endpoint(this->get_implementation(), ec);
> }
># 1473 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void shutdown(shutdown_type what)
> {
> boost::system::error_code ec;
> this->get_service().shutdown(this->get_implementation(), what, ec);
> boost::asio::detail::throw_error(ec, "shutdown");
> }
># 1502 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code shutdown(shutdown_type what,
> boost::system::error_code& ec)
> {
> return this->get_service().shutdown(this->get_implementation(), what, ec);
> }
>
>protected:
>
> ~basic_socket()
> {
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 1519 "/usr/include/boost/asio/basic_socket.hpp" 2 3 4
># 21 "/usr/include/boost/asio/basic_datagram_socket.hpp" 2 3 4
># 1 "/usr/include/boost/asio/datagram_socket_service.hpp" 1 3 4
># 19 "/usr/include/boost/asio/datagram_socket_service.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/datagram_socket_service.hpp" 2 3 4
># 28 "/usr/include/boost/asio/datagram_socket_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 3 4
># 1 "/usr/include/boost/asio/buffer.hpp" 1 3 4
># 19 "/usr/include/boost/asio/buffer.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/buffer.hpp" 2 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 21 "/usr/include/boost/asio/buffer.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/array_fwd.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/array_fwd.hpp" 3 4
>namespace boost {
>
>template<class T, std::size_t N>
>class array;
>
>}
># 24 "/usr/include/boost/asio/buffer.hpp" 2 3 4
># 58 "/usr/include/boost/asio/buffer.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 59 "/usr/include/boost/asio/buffer.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>class mutable_buffer;
>class const_buffer;
>
>namespace detail {
>void* buffer_cast_helper(const mutable_buffer&);
>const void* buffer_cast_helper(const const_buffer&);
>std::size_t buffer_size_helper(const mutable_buffer&);
>std::size_t buffer_size_helper(const const_buffer&);
>}
># 92 "/usr/include/boost/asio/buffer.hpp" 3 4
>class mutable_buffer
>{
>public:
>
> mutable_buffer()
> : data_(0),
> size_(0)
> {
> }
>
>
> mutable_buffer(void* data, std::size_t size)
> : data_(data),
> size_(size)
> {
> }
># 124 "/usr/include/boost/asio/buffer.hpp" 3 4
>private:
> friend void* boost::asio::detail::buffer_cast_helper(
> const mutable_buffer& b);
> friend std::size_t boost::asio::detail::buffer_size_helper(
> const mutable_buffer& b);
>
> void* data_;
> std::size_t size_;
>
>
>
>
>};
>
>namespace detail {
>
>inline void* buffer_cast_helper(const mutable_buffer& b)
>{
>
>
>
>
> return b.data_;
>}
>
>inline std::size_t buffer_size_helper(const mutable_buffer& b)
>{
> return b.size_;
>}
>
>}
>
>
>
>class mutable_buffers_1
> : public mutable_buffer
>{
>public:
>
> typedef mutable_buffer value_type;
>
>
> typedef const mutable_buffer* const_iterator;
>
>
> mutable_buffers_1(void* data, std::size_t size)
> : mutable_buffer(data, size)
> {
> }
>
>
> explicit mutable_buffers_1(const mutable_buffer& b)
> : mutable_buffer(b)
> {
> }
>
>
> const_iterator begin() const
> {
> return this;
> }
>
>
> const_iterator end() const
> {
> return begin() + 1;
> }
>};
># 212 "/usr/include/boost/asio/buffer.hpp" 3 4
>class const_buffer
>{
>public:
>
> const_buffer()
> : data_(0),
> size_(0)
> {
> }
>
>
> const_buffer(const void* data, std::size_t size)
> : data_(data),
> size_(size)
> {
> }
>
>
> const_buffer(const mutable_buffer& b)
> : data_(boost::asio::detail::buffer_cast_helper(b)),
> size_(boost::asio::detail::buffer_size_helper(b))
>
>
>
> {
> }
># 254 "/usr/include/boost/asio/buffer.hpp" 3 4
>private:
> friend const void* boost::asio::detail::buffer_cast_helper(
> const const_buffer& b);
> friend std::size_t boost::asio::detail::buffer_size_helper(
> const const_buffer& b);
>
> const void* data_;
> std::size_t size_;
>
>
>
>
>};
>
>namespace detail {
>
>inline const void* buffer_cast_helper(const const_buffer& b)
>{
>
>
>
>
> return b.data_;
>}
>
>inline std::size_t buffer_size_helper(const const_buffer& b)
>{
> return b.size_;
>}
>
>}
>
>
>
>class const_buffers_1
> : public const_buffer
>{
>public:
>
> typedef const_buffer value_type;
>
>
> typedef const const_buffer* const_iterator;
>
>
> const_buffers_1(const void* data, std::size_t size)
> : const_buffer(data, size)
> {
> }
>
>
> explicit const_buffers_1(const const_buffer& b)
> : const_buffer(b)
> {
> }
>
>
> const_iterator begin() const
> {
> return this;
> }
>
>
> const_iterator end() const
> {
> return begin() + 1;
> }
>};
>
>
>
>class null_buffers
>{
>public:
>
> typedef mutable_buffer value_type;
>
>
> typedef const mutable_buffer* const_iterator;
>
>
> const_iterator begin() const
> {
> return &buf_;
> }
>
>
> const_iterator end() const
> {
> return &buf_;
> }
>
>private:
> mutable_buffer buf_;
>};
># 358 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_size(const mutable_buffer& b)
>{
> return detail::buffer_size_helper(b);
>}
>
>
>inline std::size_t buffer_size(const mutable_buffers_1& b)
>{
> return detail::buffer_size_helper(b);
>}
>
>
>inline std::size_t buffer_size(const const_buffer& b)
>{
> return detail::buffer_size_helper(b);
>}
>
>
>inline std::size_t buffer_size(const const_buffers_1& b)
>{
> return detail::buffer_size_helper(b);
>}
>
>
>
>
>
>
>template <typename BufferSequence>
>inline std::size_t buffer_size(const BufferSequence& b)
>{
> std::size_t total_buffer_size = 0;
>
> typename BufferSequence::const_iterator iter = b.begin();
> typename BufferSequence::const_iterator end = b.end();
> for (; iter != end; ++iter)
> total_buffer_size += detail::buffer_size_helper(*iter);
>
> return total_buffer_size;
>}
># 424 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PointerToPodType>
>inline PointerToPodType buffer_cast(const mutable_buffer& b)
>{
> return static_cast<PointerToPodType>(detail::buffer_cast_helper(b));
>}
>
>
>template <typename PointerToPodType>
>inline PointerToPodType buffer_cast(const const_buffer& b)
>{
> return static_cast<PointerToPodType>(detail::buffer_cast_helper(b));
>}
>
>
>
>
>
>
>
>inline mutable_buffer operator+(const mutable_buffer& b, std::size_t start)
>{
> if (start > buffer_size(b))
> return mutable_buffer();
> char* new_data = buffer_cast<char*>(b) + start;
> std::size_t new_size = buffer_size(b) - start;
> return mutable_buffer(new_data, new_size
>
>
>
> );
>}
>
>
>
>
>
>inline mutable_buffer operator+(std::size_t start, const mutable_buffer& b)
>{
> if (start > buffer_size(b))
> return mutable_buffer();
> char* new_data = buffer_cast<char*>(b) + start;
> std::size_t new_size = buffer_size(b) - start;
> return mutable_buffer(new_data, new_size
>
>
>
> );
>}
>
>
>
>
>
>inline const_buffer operator+(const const_buffer& b, std::size_t start)
>{
> if (start > buffer_size(b))
> return const_buffer();
> const char* new_data = buffer_cast<const char*>(b) + start;
> std::size_t new_size = buffer_size(b) - start;
> return const_buffer(new_data, new_size
>
>
>
> );
>}
>
>
>
>
>
>inline const_buffer operator+(std::size_t start, const const_buffer& b)
>{
> if (start > buffer_size(b))
> return const_buffer();
> const char* new_data = buffer_cast<const char*>(b) + start;
> std::size_t new_size = buffer_size(b) - start;
> return const_buffer(new_data, new_size
>
>
>
> );
>}
># 704 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline mutable_buffers_1 buffer(const mutable_buffer& b)
>{
> return mutable_buffers_1(b);
>}
># 716 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline mutable_buffers_1 buffer(const mutable_buffer& b,
> std::size_t max_size_in_bytes)
>{
> return mutable_buffers_1(
> mutable_buffer(buffer_cast<void*>(b),
> buffer_size(b) < max_size_in_bytes
> ? buffer_size(b) : max_size_in_bytes
>
>
>
> ));
>}
>
>
>
>
>
>inline const_buffers_1 buffer(const const_buffer& b)
>{
> return const_buffers_1(b);
>}
># 745 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline const_buffers_1 buffer(const const_buffer& b,
> std::size_t max_size_in_bytes)
>{
> return const_buffers_1(
> const_buffer(buffer_cast<const void*>(b),
> buffer_size(b) < max_size_in_bytes
> ? buffer_size(b) : max_size_in_bytes
>
>
>
> ));
>}
>
>
>
>
>
>inline mutable_buffers_1 buffer(void* data, std::size_t size_in_bytes)
>{
> return mutable_buffers_1(mutable_buffer(data, size_in_bytes));
>}
>
>
>
>
>
>inline const_buffers_1 buffer(const void* data,
> std::size_t size_in_bytes)
>{
> return const_buffers_1(const_buffer(data, size_in_bytes));
>}
># 784 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline mutable_buffers_1 buffer(PodType (&data)[N])
>{
> return mutable_buffers_1(mutable_buffer(data, N * sizeof(PodType)));
>}
># 797 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline mutable_buffers_1 buffer(PodType (&data)[N],
> std::size_t max_size_in_bytes)
>{
> return mutable_buffers_1(
> mutable_buffer(data,
> N * sizeof(PodType) < max_size_in_bytes
> ? N * sizeof(PodType) : max_size_in_bytes));
>}
># 814 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(const PodType (&data)[N])
>{
> return const_buffers_1(const_buffer(data, N * sizeof(PodType)));
>}
># 827 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(const PodType (&data)[N],
> std::size_t max_size_in_bytes)
>{
> return const_buffers_1(
> const_buffer(data,
> N * sizeof(PodType) < max_size_in_bytes
> ? N * sizeof(PodType) : max_size_in_bytes));
>}
># 913 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline mutable_buffers_1 buffer(boost::array<PodType, N>& data)
>{
> return mutable_buffers_1(
> mutable_buffer(data.c_array(), data.size() * sizeof(PodType)));
>}
># 927 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline mutable_buffers_1 buffer(boost::array<PodType, N>& data,
> std::size_t max_size_in_bytes)
>{
> return mutable_buffers_1(
> mutable_buffer(data.c_array(),
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes));
>}
># 944 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(boost::array<const PodType, N>& data)
>{
> return const_buffers_1(
> const_buffer(data.data(), data.size() * sizeof(PodType)));
>}
># 958 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(boost::array<const PodType, N>& data,
> std::size_t max_size_in_bytes)
>{
> return const_buffers_1(
> const_buffer(data.data(),
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes));
>}
># 977 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(const boost::array<PodType, N>& data)
>{
> return const_buffers_1(
> const_buffer(data.data(), data.size() * sizeof(PodType)));
>}
># 991 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(const boost::array<PodType, N>& data,
> std::size_t max_size_in_bytes)
>{
> return const_buffers_1(
> const_buffer(data.data(),
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes));
>}
># 1010 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline mutable_buffers_1 buffer(std::array<PodType, N>& data)
>{
> return mutable_buffers_1(
> mutable_buffer(data.data(), data.size() * sizeof(PodType)));
>}
># 1024 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline mutable_buffers_1 buffer(std::array<PodType, N>& data,
> std::size_t max_size_in_bytes)
>{
> return mutable_buffers_1(
> mutable_buffer(data.data(),
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes));
>}
># 1041 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(std::array<const PodType, N>& data)
>{
> return const_buffers_1(
> const_buffer(data.data(), data.size() * sizeof(PodType)));
>}
># 1055 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(std::array<const PodType, N>& data,
> std::size_t max_size_in_bytes)
>{
> return const_buffers_1(
> const_buffer(data.data(),
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes));
>}
># 1072 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(const std::array<PodType, N>& data)
>{
> return const_buffers_1(
> const_buffer(data.data(), data.size() * sizeof(PodType)));
>}
># 1086 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(const std::array<PodType, N>& data,
> std::size_t max_size_in_bytes)
>{
> return const_buffers_1(
> const_buffer(data.data(),
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes));
>}
># 1108 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, typename Allocator>
>inline mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data)
>{
> return mutable_buffers_1(
> mutable_buffer(data.size() ? &data[0] : 0, data.size() * sizeof(PodType)
>
>
>
>
>
> ));
>}
># 1131 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, typename Allocator>
>inline mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data,
> std::size_t max_size_in_bytes)
>{
> return mutable_buffers_1(
> mutable_buffer(data.size() ? &data[0] : 0,
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes
>
>
>
>
>
> ));
>}
># 1157 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, typename Allocator>
>inline const_buffers_1 buffer(
> const std::vector<PodType, Allocator>& data)
>{
> return const_buffers_1(
> const_buffer(data.size() ? &data[0] : 0, data.size() * sizeof(PodType)
>
>
>
>
>
> ));
>}
># 1181 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, typename Allocator>
>inline const_buffers_1 buffer(
> const std::vector<PodType, Allocator>& data, std::size_t max_size_in_bytes)
>{
> return const_buffers_1(
> const_buffer(data.size() ? &data[0] : 0,
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes
>
>
>
>
>
> ));
>}
># 1204 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename Elem, typename Traits, typename Allocator>
>inline const_buffers_1 buffer(
> const std::basic_string<Elem, Traits, Allocator>& data)
>{
> return const_buffers_1(const_buffer(data.data(), data.size() * sizeof(Elem)
>
>
>
>
>
> ));
>}
># 1227 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename Elem, typename Traits, typename Allocator>
>inline const_buffers_1 buffer(
> const std::basic_string<Elem, Traits, Allocator>& data,
> std::size_t max_size_in_bytes)
>{
> return const_buffers_1(
> const_buffer(data.data(),
> data.size() * sizeof(Elem) < max_size_in_bytes
> ? data.size() * sizeof(Elem) : max_size_in_bytes
>
>
>
>
>
> ));
>}
># 1287 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffer& target,
> const const_buffer& source)
>{
> using namespace std;
> std::size_t target_size = buffer_size(target);
> std::size_t source_size = buffer_size(source);
> std::size_t n = target_size < source_size ? target_size : source_size;
> memcpy(buffer_cast<void*>(target), buffer_cast<const void*>(source), n);
> return n;
>}
># 1314 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffer& target,
> const const_buffers_1& source)
>{
> return buffer_copy(target, static_cast<const const_buffer&>(source));
>}
># 1337 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffer& target,
> const mutable_buffer& source)
>{
> return buffer_copy(target, const_buffer(source));
>}
># 1360 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffer& target,
> const mutable_buffers_1& source)
>{
> return buffer_copy(target, const_buffer(source));
>}
># 1382 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename ConstBufferSequence>
>std::size_t buffer_copy(const mutable_buffer& target,
> const ConstBufferSequence& source)
>{
> std::size_t total_bytes_copied = 0;
>
> typename ConstBufferSequence::const_iterator source_iter = source.begin();
> typename ConstBufferSequence::const_iterator source_end = source.end();
>
> for (mutable_buffer target_buffer(target);
> buffer_size(target_buffer) && source_iter != source_end; ++source_iter)
> {
> const_buffer source_buffer(*source_iter);
> std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer);
> total_bytes_copied += bytes_copied;
> target_buffer = target_buffer + bytes_copied;
> }
>
> return total_bytes_copied;
>}
># 1419 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffers_1& target,
> const const_buffer& source)
>{
> return buffer_copy(static_cast<const mutable_buffer&>(target), source);
>}
># 1441 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffers_1& target,
> const const_buffers_1& source)
>{
> return buffer_copy(static_cast<const mutable_buffer&>(target),
> static_cast<const const_buffer&>(source));
>}
># 1465 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffers_1& target,
> const mutable_buffer& source)
>{
> return buffer_copy(static_cast<const mutable_buffer&>(target),
> const_buffer(source));
>}
># 1489 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffers_1& target,
> const mutable_buffers_1& source)
>{
> return buffer_copy(static_cast<const mutable_buffer&>(target),
> const_buffer(source));
>}
># 1512 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename ConstBufferSequence>
>inline std::size_t buffer_copy(const mutable_buffers_1& target,
> const ConstBufferSequence& source)
>{
> return buffer_copy(static_cast<const mutable_buffer&>(target), source);
>}
># 1535 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename MutableBufferSequence>
>std::size_t buffer_copy(const MutableBufferSequence& target,
> const const_buffer& source)
>{
> std::size_t total_bytes_copied = 0;
>
> typename MutableBufferSequence::const_iterator target_iter = target.begin();
> typename MutableBufferSequence::const_iterator target_end = target.end();
>
> for (const_buffer source_buffer(source);
> buffer_size(source_buffer) && target_iter != target_end; ++target_iter)
> {
> mutable_buffer target_buffer(*target_iter);
> std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer);
> total_bytes_copied += bytes_copied;
> source_buffer = source_buffer + bytes_copied;
> }
>
> return total_bytes_copied;
>}
># 1572 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename MutableBufferSequence>
>inline std::size_t buffer_copy(const MutableBufferSequence& target,
> const const_buffers_1& source)
>{
> return buffer_copy(target, static_cast<const const_buffer&>(source));
>}
># 1596 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename MutableBufferSequence>
>inline std::size_t buffer_copy(const MutableBufferSequence& target,
> const mutable_buffer& source)
>{
> return buffer_copy(target, const_buffer(source));
>}
># 1620 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename MutableBufferSequence>
>inline std::size_t buffer_copy(const MutableBufferSequence& target,
> const mutable_buffers_1& source)
>{
> return buffer_copy(target, const_buffer(source));
>}
># 1643 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename MutableBufferSequence, typename ConstBufferSequence>
>std::size_t buffer_copy(const MutableBufferSequence& target,
> const ConstBufferSequence& source)
>{
> std::size_t total_bytes_copied = 0;
>
> typename MutableBufferSequence::const_iterator target_iter = target.begin();
> typename MutableBufferSequence::const_iterator target_end = target.end();
> std::size_t target_buffer_offset = 0;
>
> typename ConstBufferSequence::const_iterator source_iter = source.begin();
> typename ConstBufferSequence::const_iterator source_end = source.end();
> std::size_t source_buffer_offset = 0;
>
> while (target_iter != target_end && source_iter != source_end)
> {
> mutable_buffer target_buffer =
> mutable_buffer(*target_iter) + target_buffer_offset;
>
> const_buffer source_buffer =
> const_buffer(*source_iter) + source_buffer_offset;
>
> std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer);
> total_bytes_copied += bytes_copied;
>
> if (bytes_copied == buffer_size(target_buffer))
> {
> ++target_iter;
> target_buffer_offset = 0;
> }
> else
> target_buffer_offset += bytes_copied;
>
> if (bytes_copied == buffer_size(source_buffer))
> {
> ++source_iter;
> source_buffer_offset = 0;
> }
> else
> source_buffer_offset += bytes_copied;
> }
>
> return total_bytes_copied;
>}
># 1708 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffer& target,
> const const_buffer& source, std::size_t max_bytes_to_copy)
>{
> return buffer_copy(buffer(target, max_bytes_to_copy), source);
>}
># 1734 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffer& target,
> const const_buffers_1& source, std::size_t max_bytes_to_copy)
>{
> return buffer_copy(buffer(target, max_bytes_to_copy), source);
>}
># 1761 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffer& target,
> const mutable_buffer& source, std::size_t max_bytes_to_copy)
>{
> return buffer_copy(buffer(target, max_bytes_to_copy), source);
>}
># 1788 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffer& target,
> const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
>{
> return buffer_copy(buffer(target, max_bytes_to_copy), source);
>}
># 1815 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename ConstBufferSequence>
>inline std::size_t buffer_copy(const mutable_buffer& target,
> const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
>{
> return buffer_copy(buffer(target, max_bytes_to_copy), source);
>}
># 1842 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffers_1& target,
> const const_buffer& source, std::size_t max_bytes_to_copy)
>{
> return buffer_copy(buffer(target, max_bytes_to_copy), source);
>}
># 1868 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffers_1& target,
> const const_buffers_1& source, std::size_t max_bytes_to_copy)
>{
> return buffer_copy(buffer(target, max_bytes_to_copy), source);
>}
># 1895 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffers_1& target,
> const mutable_buffer& source, std::size_t max_bytes_to_copy)
>{
> return buffer_copy(buffer(target, max_bytes_to_copy), source);
>}
># 1922 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline std::size_t buffer_copy(const mutable_buffers_1& target,
> const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
>{
> return buffer_copy(buffer(target, max_bytes_to_copy), source);
>}
># 1949 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename ConstBufferSequence>
>inline std::size_t buffer_copy(const mutable_buffers_1& target,
> const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
>{
> return buffer_copy(buffer(target, max_bytes_to_copy), source);
>}
># 1977 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename MutableBufferSequence>
>inline std::size_t buffer_copy(const MutableBufferSequence& target,
> const const_buffer& source, std::size_t max_bytes_to_copy)
>{
> return buffer_copy(target, buffer(source, max_bytes_to_copy));
>}
># 2005 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename MutableBufferSequence>
>inline std::size_t buffer_copy(const MutableBufferSequence& target,
> const const_buffers_1& source, std::size_t max_bytes_to_copy)
>{
> return buffer_copy(target, buffer(source, max_bytes_to_copy));
>}
># 2034 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename MutableBufferSequence>
>inline std::size_t buffer_copy(const MutableBufferSequence& target,
> const mutable_buffer& source, std::size_t max_bytes_to_copy)
>{
> return buffer_copy(target, buffer(source, max_bytes_to_copy));
>}
># 2063 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename MutableBufferSequence>
>inline std::size_t buffer_copy(const MutableBufferSequence& target,
> const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
>{
> return buffer_copy(target, buffer(source, max_bytes_to_copy));
>}
># 2091 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename MutableBufferSequence, typename ConstBufferSequence>
>std::size_t buffer_copy(const MutableBufferSequence& target,
> const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
>{
> std::size_t total_bytes_copied = 0;
>
> typename MutableBufferSequence::const_iterator target_iter = target.begin();
> typename MutableBufferSequence::const_iterator target_end = target.end();
> std::size_t target_buffer_offset = 0;
>
> typename ConstBufferSequence::const_iterator source_iter = source.begin();
> typename ConstBufferSequence::const_iterator source_end = source.end();
> std::size_t source_buffer_offset = 0;
>
> while (total_bytes_copied != max_bytes_to_copy
> && target_iter != target_end && source_iter != source_end)
> {
> mutable_buffer target_buffer =
> mutable_buffer(*target_iter) + target_buffer_offset;
>
> const_buffer source_buffer =
> const_buffer(*source_iter) + source_buffer_offset;
>
> std::size_t bytes_copied = buffer_copy(target_buffer,
> source_buffer, max_bytes_to_copy - total_bytes_copied);
> total_bytes_copied += bytes_copied;
>
> if (bytes_copied == buffer_size(target_buffer))
> {
> ++target_iter;
> target_buffer_offset = 0;
> }
> else
> target_buffer_offset += bytes_copied;
>
> if (bytes_copied == buffer_size(source_buffer))
> {
> ++source_iter;
> source_buffer_offset = 0;
> }
> else
> source_buffer_offset += bytes_copied;
> }
>
> return total_bytes_copied;
>}
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 2144 "/usr/include/boost/asio/buffer.hpp" 2 3 4
># 23 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/buffer_sequence_adapter.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/buffer_sequence_adapter.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/buffer_sequence_adapter.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class buffer_sequence_adapter_base
>{
>protected:
># 49 "/usr/include/boost/asio/detail/buffer_sequence_adapter.hpp" 3 4
> typedef iovec native_buffer_type;
>
> static void init_iov_base(void*& base, void* addr)
> {
> base = addr;
> }
>
> template <typename T>
> static void init_iov_base(T& base, void* addr)
> {
> base = static_cast<T>(addr);
> }
>
> static void init_native_buffer(iovec& iov,
> const boost::asio::mutable_buffer& buffer)
> {
> init_iov_base(iov.iov_base, boost::asio::buffer_cast<void*>(buffer));
> iov.iov_len = boost::asio::buffer_size(buffer);
> }
>
> static void init_native_buffer(iovec& iov,
> const boost::asio::const_buffer& buffer)
> {
> init_iov_base(iov.iov_base, const_cast<void*>(
> boost::asio::buffer_cast<const void*>(buffer)));
> iov.iov_len = boost::asio::buffer_size(buffer);
> }
>
>};
>
>
>template <typename Buffer, typename Buffers>
>class buffer_sequence_adapter
> : buffer_sequence_adapter_base
>{
>public:
> explicit buffer_sequence_adapter(const Buffers& buffer_sequence)
> : count_(0), total_buffer_size_(0)
> {
> typename Buffers::const_iterator iter = buffer_sequence.begin();
> typename Buffers::const_iterator end = buffer_sequence.end();
> for (; iter != end && count_ < max_buffers; ++iter, ++count_)
> {
> Buffer buffer(*iter);
> init_native_buffer(buffers_[count_], buffer);
> total_buffer_size_ += boost::asio::buffer_size(buffer);
> }
> }
>
> native_buffer_type* buffers()
> {
> return buffers_;
> }
>
> std::size_t count() const
> {
> return count_;
> }
>
> bool all_empty() const
> {
> return total_buffer_size_ == 0;
> }
>
> static bool all_empty(const Buffers& buffer_sequence)
> {
> typename Buffers::const_iterator iter = buffer_sequence.begin();
> typename Buffers::const_iterator end = buffer_sequence.end();
> std::size_t i = 0;
> for (; iter != end && i < max_buffers; ++iter, ++i)
> if (boost::asio::buffer_size(Buffer(*iter)) > 0)
> return false;
> return true;
> }
>
> static void validate(const Buffers& buffer_sequence)
> {
> typename Buffers::const_iterator iter = buffer_sequence.begin();
> typename Buffers::const_iterator end = buffer_sequence.end();
> for (; iter != end; ++iter)
> {
> Buffer buffer(*iter);
> boost::asio::buffer_cast<const void*>(buffer);
> }
> }
>
> static Buffer first(const Buffers& buffer_sequence)
> {
> typename Buffers::const_iterator iter = buffer_sequence.begin();
> typename Buffers::const_iterator end = buffer_sequence.end();
> for (; iter != end; ++iter)
> {
> Buffer buffer(*iter);
> if (boost::asio::buffer_size(buffer) != 0)
> return buffer;
> }
> return Buffer();
> }
>
>private:
>
> enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
>
> native_buffer_type buffers_[max_buffers];
> std::size_t count_;
> std::size_t total_buffer_size_;
>};
>
>template <typename Buffer>
>class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffers_1>
> : buffer_sequence_adapter_base
>{
>public:
> explicit buffer_sequence_adapter(
> const boost::asio::mutable_buffers_1& buffer_sequence)
> {
> init_native_buffer(buffer_, Buffer(buffer_sequence));
> total_buffer_size_ = boost::asio::buffer_size(buffer_sequence);
> }
>
> native_buffer_type* buffers()
> {
> return &buffer_;
> }
>
> std::size_t count() const
> {
> return 1;
> }
>
> bool all_empty() const
> {
> return total_buffer_size_ == 0;
> }
>
> static bool all_empty(const boost::asio::mutable_buffers_1& buffer_sequence)
> {
> return boost::asio::buffer_size(buffer_sequence) == 0;
> }
>
> static void validate(const boost::asio::mutable_buffers_1& buffer_sequence)
> {
> boost::asio::buffer_cast<const void*>(buffer_sequence);
> }
>
> static Buffer first(const boost::asio::mutable_buffers_1& buffer_sequence)
> {
> return Buffer(buffer_sequence);
> }
>
>private:
> native_buffer_type buffer_;
> std::size_t total_buffer_size_;
>};
>
>template <typename Buffer>
>class buffer_sequence_adapter<Buffer, boost::asio::const_buffers_1>
> : buffer_sequence_adapter_base
>{
>public:
> explicit buffer_sequence_adapter(
> const boost::asio::const_buffers_1& buffer_sequence)
> {
> init_native_buffer(buffer_, Buffer(buffer_sequence));
> total_buffer_size_ = boost::asio::buffer_size(buffer_sequence);
> }
>
> native_buffer_type* buffers()
> {
> return &buffer_;
> }
>
> std::size_t count() const
> {
> return 1;
> }
>
> bool all_empty() const
> {
> return total_buffer_size_ == 0;
> }
>
> static bool all_empty(const boost::asio::const_buffers_1& buffer_sequence)
> {
> return boost::asio::buffer_size(buffer_sequence) == 0;
> }
>
> static void validate(const boost::asio::const_buffers_1& buffer_sequence)
> {
> boost::asio::buffer_cast<const void*>(buffer_sequence);
> }
>
> static Buffer first(const boost::asio::const_buffers_1& buffer_sequence)
> {
> return Buffer(buffer_sequence);
> }
>
>private:
> native_buffer_type buffer_;
> std::size_t total_buffer_size_;
>};
>
>template <typename Buffer, typename Elem>
>class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> >
> : buffer_sequence_adapter_base
>{
>public:
> explicit buffer_sequence_adapter(
> const boost::array<Elem, 2>& buffer_sequence)
> {
> init_native_buffer(buffers_[0], Buffer(buffer_sequence[0]));
> init_native_buffer(buffers_[1], Buffer(buffer_sequence[1]));
> total_buffer_size_ = boost::asio::buffer_size(buffer_sequence[0])
> + boost::asio::buffer_size(buffer_sequence[1]);
> }
>
> native_buffer_type* buffers()
> {
> return buffers_;
> }
>
> std::size_t count() const
> {
> return 2;
> }
>
> bool all_empty() const
> {
> return total_buffer_size_ == 0;
> }
>
> static bool all_empty(const boost::array<Elem, 2>& buffer_sequence)
> {
> return boost::asio::buffer_size(buffer_sequence[0]) == 0
> && boost::asio::buffer_size(buffer_sequence[1]) == 0;
> }
>
> static void validate(const boost::array<Elem, 2>& buffer_sequence)
> {
> boost::asio::buffer_cast<const void*>(buffer_sequence[0]);
> boost::asio::buffer_cast<const void*>(buffer_sequence[1]);
> }
>
> static Buffer first(const boost::array<Elem, 2>& buffer_sequence)
> {
> return Buffer(boost::asio::buffer_size(buffer_sequence[0]) != 0
> ? buffer_sequence[0] : buffer_sequence[1]);
> }
>
>private:
> native_buffer_type buffers_[2];
> std::size_t total_buffer_size_;
>};
>
>
>
>template <typename Buffer, typename Elem>
>class buffer_sequence_adapter<Buffer, std::array<Elem, 2> >
> : buffer_sequence_adapter_base
>{
>public:
> explicit buffer_sequence_adapter(
> const std::array<Elem, 2>& buffer_sequence)
> {
> init_native_buffer(buffers_[0], Buffer(buffer_sequence[0]));
> init_native_buffer(buffers_[1], Buffer(buffer_sequence[1]));
> total_buffer_size_ = boost::asio::buffer_size(buffer_sequence[0])
> + boost::asio::buffer_size(buffer_sequence[1]);
> }
>
> native_buffer_type* buffers()
> {
> return buffers_;
> }
>
> std::size_t count() const
> {
> return 2;
> }
>
> bool all_empty() const
> {
> return total_buffer_size_ == 0;
> }
>
> static bool all_empty(const std::array<Elem, 2>& buffer_sequence)
> {
> return boost::asio::buffer_size(buffer_sequence[0]) == 0
> && boost::asio::buffer_size(buffer_sequence[1]) == 0;
> }
>
> static void validate(const std::array<Elem, 2>& buffer_sequence)
> {
> boost::asio::buffer_cast<const void*>(buffer_sequence[0]);
> boost::asio::buffer_cast<const void*>(buffer_sequence[1]);
> }
>
> static Buffer first(const std::array<Elem, 2>& buffer_sequence)
> {
> return Buffer(boost::asio::buffer_size(buffer_sequence[0]) != 0
> ? buffer_sequence[0] : buffer_sequence[1]);
> }
>
>private:
> native_buffer_type buffers_[2];
> std::size_t total_buffer_size_;
>};
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 364 "/usr/include/boost/asio/detail/buffer_sequence_adapter.hpp" 2 3 4
># 28 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/reactive_null_buffers_op.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/reactive_null_buffers_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/reactive_null_buffers_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Handler>
>class reactive_null_buffers_op : public reactor_op
>{
>public:
> struct ptr { Handler* h; void* v; reactive_null_buffers_op* p; ~ptr() { reset(); } void reset() { if (p) { p->~reactive_null_buffers_op(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(reactive_null_buffers_op), *h); v = 0; } } };
>
> reactive_null_buffers_op(Handler& handler)
> : reactor_op(&reactive_null_buffers_op::do_perform,
> &reactive_null_buffers_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
> static bool do_perform(reactor_op*)
> {
> return true;
> }
>
> static void do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_null_buffers_op* o(static_cast<reactive_null_buffers_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 89 "/usr/include/boost/asio/detail/reactive_null_buffers_op.hpp" 2 3 4
># 30 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_accept_op.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/reactive_socket_accept_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/socket_holder.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/socket_holder.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/socket_ops.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/socket_ops.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/shared_ptr.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/shared_ptr.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>using std::shared_ptr;
>
>
>
>
>}
>}
>}
># 22 "/usr/include/boost/asio/detail/socket_ops.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/weak_ptr.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/weak_ptr.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>using std::weak_ptr;
>
>
>
>
>}
>}
>}
># 24 "/usr/include/boost/asio/detail/socket_ops.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/socket_ops.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>namespace socket_ops {
>
>
>enum
>{
>
> user_set_non_blocking = 1,
>
>
> internal_non_blocking = 2,
>
>
> non_blocking = user_set_non_blocking | internal_non_blocking,
>
>
> enable_connection_aborted = 4,
>
>
> user_set_linger = 8,
>
>
> stream_oriented = 16,
>
>
> datagram_oriented = 32,
>
>
> possible_dup = 64
>};
>
>typedef unsigned char state_type;
>
>struct noop_deleter { void operator()(void*) {} };
>typedef shared_ptr<void> shared_cancel_token_type;
>typedef weak_ptr<void> weak_cancel_token_type;
>
>inline socket_type accept(socket_type s, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec);
>
>inline socket_type sync_accept(socket_type s,
> state_type state, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec);
># 82 "/usr/include/boost/asio/detail/socket_ops.hpp" 3 4
>inline bool non_blocking_accept(socket_type s,
> state_type state, socket_addr_type* addr, std::size_t* addrlen,
> boost::system::error_code& ec, socket_type& new_socket);
>
>
>
>inline int bind(socket_type s, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec);
>
>inline int close(socket_type s, state_type& state,
> bool destruction, boost::system::error_code& ec);
>
>inline bool set_user_non_blocking(socket_type s,
> state_type& state, bool value, boost::system::error_code& ec);
>
>inline bool set_internal_non_blocking(socket_type s,
> state_type& state, bool value, boost::system::error_code& ec);
>
>inline int shutdown(socket_type s,
> int what, boost::system::error_code& ec);
>
>inline int connect(socket_type s, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec);
>
>inline void sync_connect(socket_type s, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec);
>
>inline bool non_blocking_connect(socket_type s,
> const socket_addr_type* addr, std::size_t addrlen,
> boost::system::error_code& ec);
>
>inline int socketpair(int af, int type, int protocol,
> socket_type sv[2], boost::system::error_code& ec);
>
>inline bool sockatmark(socket_type s, boost::system::error_code& ec);
>
>inline size_t available(socket_type s, boost::system::error_code& ec);
>
>inline int listen(socket_type s,
> int backlog, boost::system::error_code& ec);
>
>
>
>
>typedef iovec buf;
>
>
>inline void init_buf(buf& b, void* data, size_t size);
>
>inline void init_buf(buf& b, const void* data, size_t size);
>
>inline signed_size_type recv(socket_type s, buf* bufs,
> size_t count, int flags, boost::system::error_code& ec);
>
>inline size_t sync_recv(socket_type s, state_type state, buf* bufs,
> size_t count, int flags, bool all_empty, boost::system::error_code& ec);
># 147 "/usr/include/boost/asio/detail/socket_ops.hpp" 3 4
>inline bool non_blocking_recv(socket_type s,
> buf* bufs, size_t count, int flags, bool is_stream,
> boost::system::error_code& ec, size_t& bytes_transferred);
>
>
>
>inline signed_size_type recvfrom(socket_type s, buf* bufs,
> size_t count, int flags, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec);
>
>inline size_t sync_recvfrom(socket_type s, state_type state,
> buf* bufs, size_t count, int flags, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec);
># 169 "/usr/include/boost/asio/detail/socket_ops.hpp" 3 4
>inline bool non_blocking_recvfrom(socket_type s,
> buf* bufs, size_t count, int flags,
> socket_addr_type* addr, std::size_t* addrlen,
> boost::system::error_code& ec, size_t& bytes_transferred);
>
>
>
>inline signed_size_type recvmsg(socket_type s, buf* bufs,
> size_t count, int in_flags, int& out_flags,
> boost::system::error_code& ec);
>
>inline size_t sync_recvmsg(socket_type s, state_type state,
> buf* bufs, size_t count, int in_flags, int& out_flags,
> boost::system::error_code& ec);
># 192 "/usr/include/boost/asio/detail/socket_ops.hpp" 3 4
>inline bool non_blocking_recvmsg(socket_type s,
> buf* bufs, size_t count, int in_flags, int& out_flags,
> boost::system::error_code& ec, size_t& bytes_transferred);
>
>
>
>inline signed_size_type send(socket_type s, const buf* bufs,
> size_t count, int flags, boost::system::error_code& ec);
>
>inline size_t sync_send(socket_type s, state_type state,
> const buf* bufs, size_t count, int flags,
> bool all_empty, boost::system::error_code& ec);
># 213 "/usr/include/boost/asio/detail/socket_ops.hpp" 3 4
>inline bool non_blocking_send(socket_type s,
> const buf* bufs, size_t count, int flags,
> boost::system::error_code& ec, size_t& bytes_transferred);
>
>
>
>inline signed_size_type sendto(socket_type s, const buf* bufs,
> size_t count, int flags, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec);
>
>inline size_t sync_sendto(socket_type s, state_type state,
> const buf* bufs, size_t count, int flags, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec);
>
>
>
>inline bool non_blocking_sendto(socket_type s,
> const buf* bufs, size_t count, int flags,
> const socket_addr_type* addr, std::size_t addrlen,
> boost::system::error_code& ec, size_t& bytes_transferred);
>
>
>
>inline socket_type socket(int af, int type, int protocol,
> boost::system::error_code& ec);
>
>inline int setsockopt(socket_type s, state_type& state,
> int level, int optname, const void* optval,
> std::size_t optlen, boost::system::error_code& ec);
>
>inline int getsockopt(socket_type s, state_type state,
> int level, int optname, void* optval,
> size_t* optlen, boost::system::error_code& ec);
>
>inline int getpeername(socket_type s, socket_addr_type* addr,
> std::size_t* addrlen, bool cached, boost::system::error_code& ec);
>
>inline int getsockname(socket_type s, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec);
>
>inline int ioctl(socket_type s, state_type& state,
> int cmd, ioctl_arg_type* arg, boost::system::error_code& ec);
>
>inline int select(int nfds, fd_set* readfds, fd_set* writefds,
> fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec);
>
>inline int poll_read(socket_type s,
> state_type state, boost::system::error_code& ec);
>
>inline int poll_write(socket_type s,
> state_type state, boost::system::error_code& ec);
>
>inline int poll_connect(socket_type s, boost::system::error_code& ec);
>
>inline const char* inet_ntop(int af, const void* src, char* dest,
> size_t length, unsigned long scope_id, boost::system::error_code& ec);
>
>inline int inet_pton(int af, const char* src, void* dest,
> unsigned long* scope_id, boost::system::error_code& ec);
>
>inline int gethostname(char* name,
> int namelen, boost::system::error_code& ec);
>
>inline boost::system::error_code getaddrinfo(const char* host,
> const char* service, const addrinfo_type& hints,
> addrinfo_type** result, boost::system::error_code& ec);
>
>inline boost::system::error_code background_getaddrinfo(
> const weak_cancel_token_type& cancel_token, const char* host,
> const char* service, const addrinfo_type& hints,
> addrinfo_type** result, boost::system::error_code& ec);
>
>inline void freeaddrinfo(addrinfo_type* ai);
>
>inline boost::system::error_code getnameinfo(
> const socket_addr_type* addr, std::size_t addrlen,
> char* host, std::size_t hostlen, char* serv,
> std::size_t servlen, int flags, boost::system::error_code& ec);
>
>inline boost::system::error_code sync_getnameinfo(
> const socket_addr_type* addr, std::size_t addrlen,
> char* host, std::size_t hostlen, char* serv,
> std::size_t servlen, int sock_type, boost::system::error_code& ec);
>
>inline boost::system::error_code background_getnameinfo(
> const weak_cancel_token_type& cancel_token,
> const socket_addr_type* addr, std::size_t addrlen,
> char* host, std::size_t hostlen, char* serv,
> std::size_t servlen, int sock_type, boost::system::error_code& ec);
>
>inline u_long_type network_to_host_long(u_long_type value);
>
>inline u_long_type host_to_network_long(u_long_type value);
>
>inline u_short_type network_to_host_short(u_short_type value);
>
>inline u_short_type host_to_network_short(u_short_type value);
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 317 "/usr/include/boost/asio/detail/socket_ops.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 1 3 4
># 19 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
># 1 "/usr/include/c++/4.8.2/cctype" 1 3 4
># 39 "/usr/include/c++/4.8.2/cctype" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cctype" 3
># 20 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
># 1 "/usr/include/c++/4.8.2/cstdio" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstdio" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstdio" 3
># 21 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
># 1 "/usr/include/c++/4.8.2/cstdlib" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstdlib" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstdlib" 3
># 22 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 23 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
># 1 "/usr/include/c++/4.8.2/cerrno" 1 3 4
># 39 "/usr/include/c++/4.8.2/cerrno" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cerrno" 3
>
># 1 "/usr/include/errno.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cerrno" 2 3
># 24 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/socket_ops.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
># 37 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 38 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>namespace socket_ops {
># 55 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
>inline void clear_last_error()
>{
>
>
>
> (*__errno_location ()) = 0;
>
>}
>
>template <typename ReturnType>
>inline ReturnType error_wrapper(ReturnType return_value,
> boost::system::error_code& ec)
>{
>
>
>
>
> ec = boost::system::error_code((*__errno_location ()),
> boost::asio::error::get_system_category());
>
> return return_value;
>}
>
>template <typename SockLenType>
>inline socket_type call_accept(SockLenType msghdr::*,
> socket_type s, socket_addr_type* addr, std::size_t* addrlen)
>{
> SockLenType tmp_addrlen = addrlen ? (SockLenType)*addrlen : 0;
> socket_type result = ::accept(s, addr, addrlen ? &tmp_addrlen : 0);
> if (addrlen)
> *addrlen = (std::size_t)tmp_addrlen;
> return result;
>}
>
>socket_type accept(socket_type s, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return invalid_socket;
> }
>
> clear_last_error();
>
> socket_type new_s = error_wrapper(call_accept(
> &msghdr::msg_namelen, s, addr, addrlen), ec);
> if (new_s == invalid_socket)
> return new_s;
># 116 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> ec = boost::system::error_code();
> return new_s;
>}
>
>socket_type sync_accept(socket_type s, state_type state,
> socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec)
>{
>
> for (;;)
> {
>
> socket_type new_socket = socket_ops::accept(s, addr, addrlen, ec);
>
>
> if (new_socket != invalid_socket)
> return new_socket;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> {
> if (state & user_set_non_blocking)
> return invalid_socket;
>
> }
> else if (ec == boost::asio::error::connection_aborted)
> {
> if (state & enable_connection_aborted)
> return invalid_socket;
>
> }
>
> else if (ec.value() == 71)
> {
> if (state & enable_connection_aborted)
> return invalid_socket;
>
> }
>
> else
> return invalid_socket;
>
>
> if (socket_ops::poll_read(s, 0, ec) < 0)
> return invalid_socket;
> }
>}
># 211 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
>bool non_blocking_accept(socket_type s,
> state_type state, socket_addr_type* addr, std::size_t* addrlen,
> boost::system::error_code& ec, socket_type& new_socket)
>{
> for (;;)
> {
>
> new_socket = socket_ops::accept(s, addr, addrlen, ec);
>
>
> if (new_socket != invalid_socket)
> return true;
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> {
> if (state & user_set_non_blocking)
> return true;
>
> }
> else if (ec == boost::asio::error::connection_aborted)
> {
> if (state & enable_connection_aborted)
> return true;
>
> }
>
> else if (ec.value() == 71)
> {
> if (state & enable_connection_aborted)
> return true;
>
> }
>
> else
> return true;
>
> return false;
> }
>}
>
>
>
>template <typename SockLenType>
>inline int call_bind(SockLenType msghdr::*,
> socket_type s, const socket_addr_type* addr, std::size_t addrlen)
>{
> return ::bind(s, addr, (SockLenType)addrlen);
>}
>
>int bind(socket_type s, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> clear_last_error();
> int result = error_wrapper(call_bind(
> &msghdr::msg_namelen, s, addr, addrlen), ec);
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>}
>
>int close(socket_type s, state_type& state,
> bool destruction, boost::system::error_code& ec)
>{
> int result = 0;
> if (s != invalid_socket)
> {
>
>
>
> if (destruction && (state & user_set_linger))
> {
> ::linger opt;
> opt.l_onoff = 0;
> opt.l_linger = 0;
> boost::system::error_code ignored_ec;
> socket_ops::setsockopt(s, state, 1,
> 13, &opt, sizeof(opt), ignored_ec);
> }
>
> clear_last_error();
>
>
>
> result = error_wrapper(::close(s), ec);
>
>
> if (result != 0
> && (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again))
> {
># 328 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> ioctl_arg_type arg = 0;
> ::ioctl(s, 0x5421, &arg);
>
>
> state &= ~non_blocking;
>
> clear_last_error();
>
>
>
> result = error_wrapper(::close(s), ec);
>
> }
> }
>
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>}
>
>bool set_user_non_blocking(socket_type s,
> state_type& state, bool value, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return false;
> }
>
> clear_last_error();
># 370 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> ioctl_arg_type arg = (value ? 1 : 0);
> int result = error_wrapper(::ioctl(s, 0x5421, &arg), ec);
>
>
> if (result >= 0)
> {
> ec = boost::system::error_code();
> if (value)
> state |= user_set_non_blocking;
> else
> {
>
>
>
> state &= ~(user_set_non_blocking | internal_non_blocking);
> }
> return true;
> }
>
> return false;
>}
>
>bool set_internal_non_blocking(socket_type s,
> state_type& state, bool value, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return false;
> }
>
> if (!value && (state & user_set_non_blocking))
> {
>
>
>
> ec = boost::asio::error::invalid_argument;
> return false;
> }
>
> clear_last_error();
># 423 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> ioctl_arg_type arg = (value ? 1 : 0);
> int result = error_wrapper(::ioctl(s, 0x5421, &arg), ec);
>
>
> if (result >= 0)
> {
> ec = boost::system::error_code();
> if (value)
> state |= internal_non_blocking;
> else
> state &= ~internal_non_blocking;
> return true;
> }
>
> return false;
>}
>
>int shutdown(socket_type s, int what, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> clear_last_error();
> int result = error_wrapper(::shutdown(s, what), ec);
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>}
>
>template <typename SockLenType>
>inline int call_connect(SockLenType msghdr::*,
> socket_type s, const socket_addr_type* addr, std::size_t addrlen)
>{
> return ::connect(s, addr, (SockLenType)addrlen);
>}
>
>int connect(socket_type s, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> clear_last_error();
> int result = error_wrapper(call_connect(
> &msghdr::msg_namelen, s, addr, addrlen), ec);
> if (result == 0)
> ec = boost::system::error_code();
>
> else if (ec == boost::asio::error::try_again)
> ec = boost::asio::error::no_buffer_space;
>
> return result;
>}
>
>void sync_connect(socket_type s, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec)
>{
>
> socket_ops::connect(s, addr, addrlen, ec);
> if (ec != boost::asio::error::in_progress
> && ec != boost::asio::error::would_block)
> {
>
> return;
> }
>
>
> if (socket_ops::poll_connect(s, ec) < 0)
> return;
>
>
> int connect_error = 0;
> size_t connect_error_len = sizeof(connect_error);
> if (socket_ops::getsockopt(s, 0, 1, 4,
> &connect_error, &connect_error_len, ec) == socket_error_retval)
> return;
>
>
> ec = boost::system::error_code(connect_error,
> boost::asio::error::get_system_category());
>}
>
>bool non_blocking_connect(socket_type s,
> const socket_addr_type* addr, std::size_t addrlen,
> boost::system::error_code& ec)
>{
>
>
> socket_ops::connect(s, addr, addrlen, ec);
> if (ec == boost::asio::error::already_started)
> {
>
> return false;
> }
>
>
> int connect_error = 0;
> size_t connect_error_len = sizeof(connect_error);
> if (socket_ops::getsockopt(s, 0, 1, 4,
> &connect_error, &connect_error_len, ec) == 0)
> {
> if (connect_error)
> {
> ec = boost::system::error_code(connect_error,
> boost::asio::error::get_system_category());
> }
> else
> ec = boost::system::error_code();
> }
>
> return true;
>}
>
>int socketpair(int af, int type, int protocol,
> socket_type sv[2], boost::system::error_code& ec)
>{
># 553 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> clear_last_error();
> int result = error_wrapper(::socketpair(af, type, protocol, sv), ec);
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>
>}
>
>bool sockatmark(socket_type s, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return false;
> }
>
>
> ioctl_arg_type value = 0;
>
>
>
> int result = error_wrapper(::ioctl(s, 0x8905, &value), ec);
>
> if (result == 0)
> ec = boost::system::error_code();
>
> if (ec.value() == 25)
> ec = boost::asio::error::not_socket;
>
>
>
>
>
>
>
> return ec ? false : value != 0;
>}
>
>size_t available(socket_type s, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
> ioctl_arg_type value = 0;
>
>
>
> int result = error_wrapper(::ioctl(s, 0x541B, &value), ec);
>
> if (result == 0)
> ec = boost::system::error_code();
>
> if (ec.value() == 25)
> ec = boost::asio::error::not_socket;
>
>
> return ec ? static_cast<size_t>(0) : static_cast<size_t>(value);
>}
>
>int listen(socket_type s, int backlog, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> clear_last_error();
> int result = error_wrapper(::listen(s, backlog), ec);
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>}
>
>inline void init_buf_iov_base(void*& base, void* addr)
>{
> base = addr;
>}
>
>template <typename T>
>inline void init_buf_iov_base(T& base, void* addr)
>{
> base = static_cast<T>(addr);
>}
>
>
>
>
>typedef iovec buf;
>
>
>void init_buf(buf& b, void* data, size_t size)
>{
>
>
>
>
> init_buf_iov_base(b.iov_base, data);
> b.iov_len = size;
>
>}
>
>void init_buf(buf& b, const void* data, size_t size)
>{
>
>
>
>
> init_buf_iov_base(b.iov_base, const_cast<void*>(data));
> b.iov_len = size;
>
>}
>
>inline void init_msghdr_msg_name(void*& name, socket_addr_type* addr)
>{
> name = addr;
>}
>
>inline void init_msghdr_msg_name(void*& name, const socket_addr_type* addr)
>{
> name = const_cast<socket_addr_type*>(addr);
>}
>
>template <typename T>
>inline void init_msghdr_msg_name(T& name, socket_addr_type* addr)
>{
> name = reinterpret_cast<T>(addr);
>}
>
>template <typename T>
>inline void init_msghdr_msg_name(T& name, const socket_addr_type* addr)
>{
> name = reinterpret_cast<T>(const_cast<socket_addr_type*>(addr));
>}
>
>signed_size_type recv(socket_type s, buf* bufs, size_t count,
> int flags, boost::system::error_code& ec)
>{
> clear_last_error();
># 711 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> msghdr msg = msghdr();
> msg.msg_iov = bufs;
> msg.msg_iovlen = static_cast<int>(count);
> signed_size_type result = error_wrapper(::recvmsg(s, &msg, flags), ec);
> if (result >= 0)
> ec = boost::system::error_code();
> return result;
>
>}
>
>size_t sync_recv(socket_type s, state_type state, buf* bufs,
> size_t count, int flags, bool all_empty, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
>
> if (all_empty && (state & stream_oriented))
> {
> ec = boost::system::error_code();
> return 0;
> }
>
>
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec);
>
>
> if (bytes > 0)
> return bytes;
>
>
> if ((state & stream_oriented) && bytes == 0)
> {
> ec = boost::asio::error::eof;
> return 0;
> }
>
>
> if ((state & user_set_non_blocking)
> || (ec != boost::asio::error::would_block
> && ec != boost::asio::error::try_again))
> return 0;
>
>
> if (socket_ops::poll_read(s, 0, ec) < 0)
> return 0;
> }
>}
># 796 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
>bool non_blocking_recv(socket_type s,
> buf* bufs, size_t count, int flags, bool is_stream,
> boost::system::error_code& ec, size_t& bytes_transferred)
>{
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec);
>
>
> if (is_stream && bytes == 0)
> {
> ec = boost::asio::error::eof;
> return true;
> }
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> return false;
>
>
> if (bytes >= 0)
> {
> ec = boost::system::error_code();
> bytes_transferred = bytes;
> }
> else
> bytes_transferred = 0;
>
> return true;
> }
>}
>
>
>
>signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
> int flags, socket_addr_type* addr, std::size_t* addrlen,
> boost::system::error_code& ec)
>{
> clear_last_error();
># 859 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> msghdr msg = msghdr();
> init_msghdr_msg_name(msg.msg_name, addr);
> msg.msg_namelen = static_cast<int>(*addrlen);
> msg.msg_iov = bufs;
> msg.msg_iovlen = static_cast<int>(count);
> signed_size_type result = error_wrapper(::recvmsg(s, &msg, flags), ec);
> *addrlen = msg.msg_namelen;
> if (result >= 0)
> ec = boost::system::error_code();
> return result;
>
>}
>
>size_t sync_recvfrom(socket_type s, state_type state, buf* bufs,
> size_t count, int flags, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
>
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::recvfrom(
> s, bufs, count, flags, addr, addrlen, ec);
>
>
> if (bytes >= 0)
> return bytes;
>
>
> if ((state & user_set_non_blocking)
> || (ec != boost::asio::error::would_block
> && ec != boost::asio::error::try_again))
> return 0;
>
>
> if (socket_ops::poll_read(s, 0, ec) < 0)
> return 0;
> }
>}
># 927 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
>bool non_blocking_recvfrom(socket_type s,
> buf* bufs, size_t count, int flags,
> socket_addr_type* addr, std::size_t* addrlen,
> boost::system::error_code& ec, size_t& bytes_transferred)
>{
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::recvfrom(
> s, bufs, count, flags, addr, addrlen, ec);
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> return false;
>
>
> if (bytes >= 0)
> {
> ec = boost::system::error_code();
> bytes_transferred = bytes;
> }
> else
> bytes_transferred = 0;
>
> return true;
> }
>}
>
>
>
>signed_size_type recvmsg(socket_type s, buf* bufs, size_t count,
> int in_flags, int& out_flags, boost::system::error_code& ec)
>{
> clear_last_error();
>
>
>
>
> msghdr msg = msghdr();
> msg.msg_iov = bufs;
> msg.msg_iovlen = static_cast<int>(count);
> signed_size_type result = error_wrapper(::recvmsg(s, &msg, in_flags), ec);
> if (result >= 0)
> {
> ec = boost::system::error_code();
> out_flags = msg.msg_flags;
> }
> else
> out_flags = 0;
> return result;
>
>}
>
>size_t sync_recvmsg(socket_type s, state_type state,
> buf* bufs, size_t count, int in_flags, int& out_flags,
> boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
>
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::recvmsg(
> s, bufs, count, in_flags, out_flags, ec);
>
>
> if (bytes >= 0)
> return bytes;
>
>
> if ((state & user_set_non_blocking)
> || (ec != boost::asio::error::would_block
> && ec != boost::asio::error::try_again))
> return 0;
>
>
> if (socket_ops::poll_read(s, 0, ec) < 0)
> return 0;
> }
>}
># 1040 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
>bool non_blocking_recvmsg(socket_type s,
> buf* bufs, size_t count, int in_flags, int& out_flags,
> boost::system::error_code& ec, size_t& bytes_transferred)
>{
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::recvmsg(
> s, bufs, count, in_flags, out_flags, ec);
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> return false;
>
>
> if (bytes >= 0)
> {
> ec = boost::system::error_code();
> bytes_transferred = bytes;
> }
> else
> bytes_transferred = 0;
>
> return true;
> }
>}
>
>
>
>signed_size_type send(socket_type s, const buf* bufs, size_t count,
> int flags, boost::system::error_code& ec)
>{
> clear_last_error();
># 1094 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> msghdr msg = msghdr();
> msg.msg_iov = const_cast<buf*>(bufs);
> msg.msg_iovlen = static_cast<int>(count);
>
> flags |= MSG_NOSIGNAL;
>
> signed_size_type result = error_wrapper(::sendmsg(s, &msg, flags), ec);
> if (result >= 0)
> ec = boost::system::error_code();
> return result;
>
>}
>
>size_t sync_send(socket_type s, state_type state, const buf* bufs,
> size_t count, int flags, bool all_empty, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
>
> if (all_empty && (state & stream_oriented))
> {
> ec = boost::system::error_code();
> return 0;
> }
>
>
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec);
>
>
> if (bytes >= 0)
> return bytes;
>
>
> if ((state & user_set_non_blocking)
> || (ec != boost::asio::error::would_block
> && ec != boost::asio::error::try_again))
> return 0;
>
>
> if (socket_ops::poll_write(s, 0, ec) < 0)
> return 0;
> }
>}
># 1167 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
>bool non_blocking_send(socket_type s,
> const buf* bufs, size_t count, int flags,
> boost::system::error_code& ec, size_t& bytes_transferred)
>{
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec);
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> return false;
>
>
> if (bytes >= 0)
> {
> ec = boost::system::error_code();
> bytes_transferred = bytes;
> }
> else
> bytes_transferred = 0;
>
> return true;
> }
>}
>
>
>
>signed_size_type sendto(socket_type s, const buf* bufs, size_t count,
> int flags, const socket_addr_type* addr, std::size_t addrlen,
> boost::system::error_code& ec)
>{
> clear_last_error();
># 1221 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> msghdr msg = msghdr();
> init_msghdr_msg_name(msg.msg_name, addr);
> msg.msg_namelen = static_cast<int>(addrlen);
> msg.msg_iov = const_cast<buf*>(bufs);
> msg.msg_iovlen = static_cast<int>(count);
>
> flags |= MSG_NOSIGNAL;
>
> signed_size_type result = error_wrapper(::sendmsg(s, &msg, flags), ec);
> if (result >= 0)
> ec = boost::system::error_code();
> return result;
>
>}
>
>size_t sync_sendto(socket_type s, state_type state, const buf* bufs,
> size_t count, int flags, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
>
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::sendto(
> s, bufs, count, flags, addr, addrlen, ec);
>
>
> if (bytes >= 0)
> return bytes;
>
>
> if ((state & user_set_non_blocking)
> || (ec != boost::asio::error::would_block
> && ec != boost::asio::error::try_again))
> return 0;
>
>
> if (socket_ops::poll_write(s, 0, ec) < 0)
> return 0;
> }
>}
>
>
>
>bool non_blocking_sendto(socket_type s,
> const buf* bufs, size_t count, int flags,
> const socket_addr_type* addr, std::size_t addrlen,
> boost::system::error_code& ec, size_t& bytes_transferred)
>{
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::sendto(
> s, bufs, count, flags, addr, addrlen, ec);
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> return false;
>
>
> if (bytes >= 0)
> {
> ec = boost::system::error_code();
> bytes_transferred = bytes;
> }
> else
> bytes_transferred = 0;
>
> return true;
> }
>}
>
>
>
>socket_type socket(int af, int type, int protocol,
> boost::system::error_code& ec)
>{
> clear_last_error();
># 1345 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> int s = error_wrapper(::socket(af, type, protocol), ec);
> if (s >= 0)
> ec = boost::system::error_code();
> return s;
>
>}
>
>template <typename SockLenType>
>inline int call_setsockopt(SockLenType msghdr::*,
> socket_type s, int level, int optname,
> const void* optval, std::size_t optlen)
>{
> return ::setsockopt(s, level, optname,
> (const char*)optval, (SockLenType)optlen);
>}
>
>int setsockopt(socket_type s, state_type& state, int level, int optname,
> const void* optval, std::size_t optlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> if (level == custom_socket_option_level && optname == always_fail_option)
> {
> ec = boost::asio::error::invalid_argument;
> return socket_error_retval;
> }
>
> if (level == custom_socket_option_level
> && optname == enable_connection_aborted_option)
> {
> if (optlen != sizeof(int))
> {
> ec = boost::asio::error::invalid_argument;
> return socket_error_retval;
> }
>
> if (*static_cast<const int*>(optval))
> state |= enable_connection_aborted;
> else
> state &= ~enable_connection_aborted;
> ec = boost::system::error_code();
> return 0;
> }
>
> if (level == 1 && optname == 13)
> state |= user_set_linger;
># 1414 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> clear_last_error();
> int result = error_wrapper(call_setsockopt(&msghdr::msg_namelen,
> s, level, optname, optval, optlen), ec);
> if (result == 0)
> {
> ec = boost::system::error_code();
># 1432 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> }
>
> return result;
>
>}
>
>template <typename SockLenType>
>inline int call_getsockopt(SockLenType msghdr::*,
> socket_type s, int level, int optname,
> void* optval, std::size_t* optlen)
>{
> SockLenType tmp_optlen = (SockLenType)*optlen;
> int result = ::getsockopt(s, level, optname, (char*)optval, &tmp_optlen);
> *optlen = (std::size_t)tmp_optlen;
> return result;
>}
>
>int getsockopt(socket_type s, state_type state, int level, int optname,
> void* optval, size_t* optlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> if (level == custom_socket_option_level && optname == always_fail_option)
> {
> ec = boost::asio::error::invalid_argument;
> return socket_error_retval;
> }
>
> if (level == custom_socket_option_level
> && optname == enable_connection_aborted_option)
> {
> if (*optlen != sizeof(int))
> {
> ec = boost::asio::error::invalid_argument;
> return socket_error_retval;
> }
>
> *static_cast<int*>(optval) = (state & enable_connection_aborted) ? 1 : 0;
> ec = boost::system::error_code();
> return 0;
> }
># 1527 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> clear_last_error();
> int result = error_wrapper(call_getsockopt(&msghdr::msg_namelen,
> s, level, optname, optval, optlen), ec);
>
> if (result == 0 && level == 1 && *optlen == sizeof(int)
> && (optname == 7 || optname == 8))
> {
>
>
>
>
>
> *static_cast<int*>(optval) /= 2;
> }
>
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>
>}
>
>template <typename SockLenType>
>inline int call_getpeername(SockLenType msghdr::*,
> socket_type s, socket_addr_type* addr, std::size_t* addrlen)
>{
> SockLenType tmp_addrlen = (SockLenType)*addrlen;
> int result = ::getpeername(s, addr, &tmp_addrlen);
> *addrlen = (std::size_t)tmp_addrlen;
> return result;
>}
>
>int getpeername(socket_type s, socket_addr_type* addr,
> std::size_t* addrlen, bool cached, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
># 1589 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> (void)cached;
>
>
> clear_last_error();
> int result = error_wrapper(call_getpeername(
> &msghdr::msg_namelen, s, addr, addrlen), ec);
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>}
>
>template <typename SockLenType>
>inline int call_getsockname(SockLenType msghdr::*,
> socket_type s, socket_addr_type* addr, std::size_t* addrlen)
>{
> SockLenType tmp_addrlen = (SockLenType)*addrlen;
> int result = ::getsockname(s, addr, &tmp_addrlen);
> *addrlen = (std::size_t)tmp_addrlen;
> return result;
>}
>
>int getsockname(socket_type s, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> clear_last_error();
> int result = error_wrapper(call_getsockname(
> &msghdr::msg_namelen, s, addr, addrlen), ec);
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>}
>
>int ioctl(socket_type s, state_type& state, int cmd,
> ioctl_arg_type* arg, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> clear_last_error();
>
>
>
>
>
>
>
> int result = error_wrapper(::ioctl(s, cmd, arg), ec);
>
> if (result >= 0)
> {
> ec = boost::system::error_code();
>
>
>
>
>
>
> if (cmd == static_cast<int>(0x5421))
> {
> if (*arg)
> {
> state |= user_set_non_blocking;
> }
> else
> {
>
>
>
> state &= ~(user_set_non_blocking | internal_non_blocking);
> }
> }
> }
>
> return result;
>}
>
>int select(int nfds, fd_set* readfds, fd_set* writefds,
> fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec)
>{
> clear_last_error();
># 1707 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> int result = error_wrapper(::select(nfds, readfds,
> writefds, exceptfds, timeout), ec);
> if (result >= 0)
> ec = boost::system::error_code();
> return result;
>
>}
>
>int poll_read(socket_type s, state_type state, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
># 1738 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> pollfd fds;
> fds.fd = s;
> fds.events = 0x001;
> fds.revents = 0;
> int timeout = (state & user_set_non_blocking) ? 0 : -1;
> clear_last_error();
> int result = error_wrapper(::poll(&fds, 1, timeout), ec);
>
>
>
> if (result == 0)
> ec = (state & user_set_non_blocking)
> ? boost::asio::error::would_block : boost::system::error_code();
> else if (result > 0)
> ec = boost::system::error_code();
> return result;
>}
>
>int poll_write(socket_type s, state_type state, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
># 1779 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> pollfd fds;
> fds.fd = s;
> fds.events = 0x004;
> fds.revents = 0;
> int timeout = (state & user_set_non_blocking) ? 0 : -1;
> clear_last_error();
> int result = error_wrapper(::poll(&fds, 1, timeout), ec);
>
>
>
> if (result == 0)
> ec = (state & user_set_non_blocking)
> ? boost::asio::error::would_block : boost::system::error_code();
> else if (result > 0)
> ec = boost::system::error_code();
> return result;
>}
>
>int poll_connect(socket_type s, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
># 1822 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> pollfd fds;
> fds.fd = s;
> fds.events = 0x004;
> fds.revents = 0;
> clear_last_error();
> int result = error_wrapper(::poll(&fds, 1, -1), ec);
> if (result >= 0)
> ec = boost::system::error_code();
> return result;
>
>
>
>}
>
>const char* inet_ntop(int af, const void* src, char* dest, size_t length,
> unsigned long scope_id, boost::system::error_code& ec)
>{
> clear_last_error();
># 1895 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> const char* result = error_wrapper(::inet_ntop(
> af, src, dest, static_cast<int>(length)), ec);
> if (result == 0 && !ec)
> ec = boost::asio::error::invalid_argument;
> if (result != 0 && af == 10 && scope_id != 0)
> {
> using namespace std;
> char if_name[16 + 1] = "%";
> const in6_addr_type* ipv6_address = static_cast<const in6_addr_type*>(src);
> bool is_link_local = ((ipv6_address->__in6_u.__u6_addr8[0] == 0xfe)
> && ((ipv6_address->__in6_u.__u6_addr8[1] & 0xc0) == 0x80));
> if (!is_link_local
> || if_indextoname(static_cast<unsigned>(scope_id), if_name + 1) == 0)
> sprintf(if_name + 1, "%lu", scope_id);
> strcat(dest, if_name);
> }
> return result;
>
>}
>
>int inet_pton(int af, const char* src, void* dest,
> unsigned long* scope_id, boost::system::error_code& ec)
>{
> clear_last_error();
># 1980 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> int result = error_wrapper(::inet_pton(af, src, dest), ec);
> if (result <= 0 && !ec)
> ec = boost::asio::error::invalid_argument;
> if (result > 0 && af == 10 && scope_id)
> {
> using namespace std;
> *scope_id = 0;
> if (const char* if_name = strchr(src, '%'))
> {
> in6_addr_type* ipv6_address = static_cast<in6_addr_type*>(dest);
> bool is_link_local = ((ipv6_address->__in6_u.__u6_addr8[0] == 0xfe)
> && ((ipv6_address->__in6_u.__u6_addr8[1] & 0xc0) == 0x80));
> if (is_link_local)
> *scope_id = if_nametoindex(if_name + 1);
> if (*scope_id == 0)
> *scope_id = atoi(if_name + 1);
> }
> }
> return result;
>
>}
>
>int gethostname(char* name, int namelen, boost::system::error_code& ec)
>{
> clear_last_error();
> int result = error_wrapper(::gethostname(name, namelen), ec);
>
>
>
>
> return result;
>}
># 2852 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
>inline boost::system::error_code translate_addrinfo_error(int error)
>{
> switch (error)
> {
> case 0:
> return boost::system::error_code();
> case -3:
> return boost::asio::error::host_not_found_try_again;
> case -1:
> return boost::asio::error::invalid_argument;
> case -4:
> return boost::asio::error::no_recovery;
> case -6:
> return boost::asio::error::address_family_not_supported;
> case -10:
> return boost::asio::error::no_memory;
> case -2:
>
> case -9:
>
>
> case -5:
>
> return boost::asio::error::host_not_found;
> case -8:
> return boost::asio::error::service_not_found;
> case -7:
> return boost::asio::error::socket_type_not_supported;
> default:
>
>
>
>
> return boost::system::error_code(
> (*__errno_location ()), boost::asio::error::get_system_category());
>
> }
>}
>
>boost::system::error_code getaddrinfo(const char* host,
> const char* service, const addrinfo_type& hints,
> addrinfo_type** result, boost::system::error_code& ec)
>{
> host = (host && *host) ? host : 0;
> service = (service && *service) ? service : 0;
> clear_last_error();
># 2922 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> int error = ::getaddrinfo(host, service, &hints, result);
> return ec = translate_addrinfo_error(error);
>
>}
>
>boost::system::error_code background_getaddrinfo(
> const weak_cancel_token_type& cancel_token, const char* host,
> const char* service, const addrinfo_type& hints,
> addrinfo_type** result, boost::system::error_code& ec)
>{
> if (cancel_token.expired())
> ec = boost::asio::error::operation_aborted;
> else
> socket_ops::getaddrinfo(host, service, hints, result, ec);
> return ec;
>}
>
>void freeaddrinfo(addrinfo_type* ai)
>{
># 2961 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> ::freeaddrinfo(ai);
>
>}
>
>boost::system::error_code getnameinfo(const socket_addr_type* addr,
> std::size_t addrlen, char* host, std::size_t hostlen,
> char* serv, std::size_t servlen, int flags, boost::system::error_code& ec)
>{
># 3006 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> clear_last_error();
> int error = ::getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags);
> return ec = translate_addrinfo_error(error);
>
>}
>
>boost::system::error_code sync_getnameinfo(
> const socket_addr_type* addr, std::size_t addrlen,
> char* host, std::size_t hostlen, char* serv,
> std::size_t servlen, int sock_type, boost::system::error_code& ec)
>{
>
>
> int flags = (sock_type == SOCK_DGRAM) ? 16 : 0;
> socket_ops::getnameinfo(addr, addrlen, host,
> hostlen, serv, servlen, flags, ec);
> if (ec)
> {
> socket_ops::getnameinfo(addr, addrlen, host, hostlen,
> serv, servlen, flags | 2, ec);
> }
>
> return ec;
>}
>
>boost::system::error_code background_getnameinfo(
> const weak_cancel_token_type& cancel_token,
> const socket_addr_type* addr, std::size_t addrlen,
> char* host, std::size_t hostlen, char* serv,
> std::size_t servlen, int sock_type, boost::system::error_code& ec)
>{
> if (cancel_token.expired())
> {
> ec = boost::asio::error::operation_aborted;
> }
> else
> {
>
>
> int flags = (sock_type == SOCK_DGRAM) ? 16 : 0;
> socket_ops::getnameinfo(addr, addrlen, host,
> hostlen, serv, servlen, flags, ec);
> if (ec)
> {
> socket_ops::getnameinfo(addr, addrlen, host, hostlen,
> serv, servlen, flags | 2, ec);
> }
> }
>
> return ec;
>}
>
>u_long_type network_to_host_long(u_long_type value)
>{
> return __bswap_32 (value);
>}
>
>u_long_type host_to_network_long(u_long_type value)
>{
> return __bswap_32 (value);
>}
>
>u_short_type network_to_host_short(u_short_type value)
>{
> return (__extension__ ({ unsigned short int __v, __x = (unsigned short int) (value); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }));
>}
>
>u_short_type host_to_network_short(u_short_type value)
>{
> return (__extension__ ({ unsigned short int __v, __x = (unsigned short int) (value); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }));
>}
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 3084 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
># 320 "/usr/include/boost/asio/detail/socket_ops.hpp" 2 3 4
># 21 "/usr/include/boost/asio/detail/socket_holder.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/socket_holder.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>class socket_holder
> : private noncopyable
>{
>public:
>
> socket_holder()
> : socket_(invalid_socket)
> {
> }
>
>
> explicit socket_holder(socket_type s)
> : socket_(s)
> {
> }
>
>
> ~socket_holder()
> {
> if (socket_ != invalid_socket)
> {
> boost::system::error_code ec;
> socket_ops::state_type state = 0;
> socket_ops::close(socket_, state, true, ec);
> }
> }
>
>
> socket_type get() const
> {
> return socket_;
> }
>
>
> void reset()
> {
> if (socket_ != invalid_socket)
> {
> boost::system::error_code ec;
> socket_ops::state_type state = 0;
> socket_ops::close(socket_, state, true, ec);
> socket_ = invalid_socket;
> }
> }
>
>
> void reset(socket_type s)
> {
> reset();
> socket_ = s;
> }
>
>
> socket_type release()
> {
> socket_type tmp = socket_;
> socket_ = invalid_socket;
> return tmp;
> }
>
>private:
>
> socket_type socket_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 99 "/usr/include/boost/asio/detail/socket_holder.hpp" 2 3 4
># 25 "/usr/include/boost/asio/detail/reactive_socket_accept_op.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/detail/reactive_socket_accept_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Socket, typename Protocol>
>class reactive_socket_accept_op_base : public reactor_op
>{
>public:
> reactive_socket_accept_op_base(socket_type socket,
> socket_ops::state_type state, Socket& peer, const Protocol& protocol,
> typename Protocol::endpoint* peer_endpoint, func_type complete_func)
> : reactor_op(&reactive_socket_accept_op_base::do_perform, complete_func),
> socket_(socket),
> state_(state),
> peer_(peer),
> protocol_(protocol),
> peer_endpoint_(peer_endpoint)
> {
> }
>
> static bool do_perform(reactor_op* base)
> {
> reactive_socket_accept_op_base* o(
> static_cast<reactive_socket_accept_op_base*>(base));
>
> std::size_t addrlen = o->peer_endpoint_ ? o->peer_endpoint_->capacity() : 0;
> socket_type new_socket = invalid_socket;
> bool result = socket_ops::non_blocking_accept(o->socket_,
> o->state_, o->peer_endpoint_ ? o->peer_endpoint_->data() : 0,
> o->peer_endpoint_ ? &addrlen : 0, o->ec_, new_socket);
>
>
> if (new_socket >= 0)
> {
> socket_holder new_socket_holder(new_socket);
> if (o->peer_endpoint_)
> o->peer_endpoint_->resize(addrlen);
> if (!o->peer_.assign(o->protocol_, new_socket, o->ec_))
> new_socket_holder.release();
> }
>
> return result;
> }
>
>private:
> socket_type socket_;
> socket_ops::state_type state_;
> Socket& peer_;
> Protocol protocol_;
> typename Protocol::endpoint* peer_endpoint_;
>};
>
>template <typename Socket, typename Protocol, typename Handler>
>class reactive_socket_accept_op :
> public reactive_socket_accept_op_base<Socket, Protocol>
>{
>public:
> struct ptr { Handler* h; void* v; reactive_socket_accept_op* p; ~ptr() { reset(); } void reset() { if (p) { p->~reactive_socket_accept_op(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(reactive_socket_accept_op), *h); v = 0; } } };
>
> reactive_socket_accept_op(socket_type socket,
> socket_ops::state_type state, Socket& peer, const Protocol& protocol,
> typename Protocol::endpoint* peer_endpoint, Handler& handler)
> : reactive_socket_accept_op_base<Socket, Protocol>(socket, state, peer,
> protocol, peer_endpoint, &reactive_socket_accept_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
> static void do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_socket_accept_op* o(static_cast<reactive_socket_accept_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder1<Handler, boost::system::error_code>
> handler(o->handler_, o->ec_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 137 "/usr/include/boost/asio/detail/reactive_socket_accept_op.hpp" 2 3 4
># 31 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_connect_op.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/reactive_socket_connect_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/reactive_socket_connect_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Protocol>
>class reactive_socket_connect_op_base : public reactor_op
>{
>public:
> reactive_socket_connect_op_base(socket_type socket,
> const typename Protocol::endpoint& peer_endpoint, func_type complete_func)
> : reactor_op(&reactive_socket_connect_op_base::do_perform, complete_func),
> socket_(socket),
> peer_endpoint_(peer_endpoint)
> {
> }
>
> static bool do_perform(reactor_op* base)
> {
> reactive_socket_connect_op_base* o(
> static_cast<reactive_socket_connect_op_base*>(base));
>
> return socket_ops::non_blocking_connect(o->socket_,
> o->peer_endpoint_.data(), o->peer_endpoint_.size(), o->ec_);
> }
>
>private:
> socket_type socket_;
> typename Protocol::endpoint peer_endpoint_;
>};
>
>template <typename Protocol, typename Handler>
>class reactive_socket_connect_op :
> public reactive_socket_connect_op_base<Protocol>
>{
>public:
> struct ptr { Handler* h; void* v; reactive_socket_connect_op* p; ~ptr() { reset(); } void reset() { if (p) { p->~reactive_socket_connect_op(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(reactive_socket_connect_op), *h); v = 0; } } };
>
> reactive_socket_connect_op(socket_type socket,
> const typename Protocol::endpoint& peer_endpoint, Handler& handler)
> : reactive_socket_connect_op_base<Protocol>(socket, peer_endpoint,
> &reactive_socket_connect_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
> static void do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_socket_connect_op* o
> (static_cast<reactive_socket_connect_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder1<Handler, boost::system::error_code>
> handler(o->handler_, o->ec_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 114 "/usr/include/boost/asio/detail/reactive_socket_connect_op.hpp" 2 3 4
># 32 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_recvfrom_op.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/reactive_socket_recvfrom_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/reactive_socket_recvfrom_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename MutableBufferSequence, typename Endpoint>
>class reactive_socket_recvfrom_op_base : public reactor_op
>{
>public:
> reactive_socket_recvfrom_op_base(socket_type socket, int protocol_type,
> const MutableBufferSequence& buffers, Endpoint& endpoint,
> socket_base::message_flags flags, func_type complete_func)
> : reactor_op(&reactive_socket_recvfrom_op_base::do_perform, complete_func),
> socket_(socket),
> protocol_type_(protocol_type),
> buffers_(buffers),
> sender_endpoint_(endpoint),
> flags_(flags)
> {
> }
>
> static bool do_perform(reactor_op* base)
> {
> reactive_socket_recvfrom_op_base* o(
> static_cast<reactive_socket_recvfrom_op_base*>(base));
>
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(o->buffers_);
>
> std::size_t addr_len = o->sender_endpoint_.capacity();
> bool result = socket_ops::non_blocking_recvfrom(o->socket_,
> bufs.buffers(), bufs.count(), o->flags_,
> o->sender_endpoint_.data(), &addr_len,
> o->ec_, o->bytes_transferred_);
>
> if (result && !o->ec_)
> o->sender_endpoint_.resize(addr_len);
>
> return result;
> }
>
>private:
> socket_type socket_;
> int protocol_type_;
> MutableBufferSequence buffers_;
> Endpoint& sender_endpoint_;
> socket_base::message_flags flags_;
>};
>
>template <typename MutableBufferSequence, typename Endpoint, typename Handler>
>class reactive_socket_recvfrom_op :
> public reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>
>{
>public:
> struct ptr { Handler* h; void* v; reactive_socket_recvfrom_op* p; ~ptr() { reset(); } void reset() { if (p) { p->~reactive_socket_recvfrom_op(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(reactive_socket_recvfrom_op), *h); v = 0; } } };
>
> reactive_socket_recvfrom_op(socket_type socket, int protocol_type,
> const MutableBufferSequence& buffers, Endpoint& endpoint,
> socket_base::message_flags flags, Handler& handler)
> : reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>(
> socket, protocol_type, buffers, endpoint, flags,
> &reactive_socket_recvfrom_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
> static void do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_socket_recvfrom_op* o(
> static_cast<reactive_socket_recvfrom_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 134 "/usr/include/boost/asio/detail/reactive_socket_recvfrom_op.hpp" 2 3 4
># 33 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_sendto_op.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/reactive_socket_sendto_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/reactive_socket_sendto_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename ConstBufferSequence, typename Endpoint>
>class reactive_socket_sendto_op_base : public reactor_op
>{
>public:
> reactive_socket_sendto_op_base(socket_type socket,
> const ConstBufferSequence& buffers, const Endpoint& endpoint,
> socket_base::message_flags flags, func_type complete_func)
> : reactor_op(&reactive_socket_sendto_op_base::do_perform, complete_func),
> socket_(socket),
> buffers_(buffers),
> destination_(endpoint),
> flags_(flags)
> {
> }
>
> static bool do_perform(reactor_op* base)
> {
> reactive_socket_sendto_op_base* o(
> static_cast<reactive_socket_sendto_op_base*>(base));
>
> buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence> bufs(o->buffers_);
>
> return socket_ops::non_blocking_sendto(o->socket_,
> bufs.buffers(), bufs.count(), o->flags_,
> o->destination_.data(), o->destination_.size(),
> o->ec_, o->bytes_transferred_);
> }
>
>private:
> socket_type socket_;
> ConstBufferSequence buffers_;
> Endpoint destination_;
> socket_base::message_flags flags_;
>};
>
>template <typename ConstBufferSequence, typename Endpoint, typename Handler>
>class reactive_socket_sendto_op :
> public reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint>
>{
>public:
> struct ptr { Handler* h; void* v; reactive_socket_sendto_op* p; ~ptr() { reset(); } void reset() { if (p) { p->~reactive_socket_sendto_op(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(reactive_socket_sendto_op), *h); v = 0; } } };
>
> reactive_socket_sendto_op(socket_type socket,
> const ConstBufferSequence& buffers, const Endpoint& endpoint,
> socket_base::message_flags flags, Handler& handler)
> : reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint>(socket,
> buffers, endpoint, flags, &reactive_socket_sendto_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
> static void do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_socket_sendto_op* o(static_cast<reactive_socket_sendto_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 124 "/usr/include/boost/asio/detail/reactive_socket_sendto_op.hpp" 2 3 4
># 34 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 1 3 4
># 29 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_recv_op.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/reactive_socket_recv_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/reactive_socket_recv_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename MutableBufferSequence>
>class reactive_socket_recv_op_base : public reactor_op
>{
>public:
> reactive_socket_recv_op_base(socket_type socket,
> socket_ops::state_type state, const MutableBufferSequence& buffers,
> socket_base::message_flags flags, func_type complete_func)
> : reactor_op(&reactive_socket_recv_op_base::do_perform, complete_func),
> socket_(socket),
> state_(state),
> buffers_(buffers),
> flags_(flags)
> {
> }
>
> static bool do_perform(reactor_op* base)
> {
> reactive_socket_recv_op_base* o(
> static_cast<reactive_socket_recv_op_base*>(base));
>
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(o->buffers_);
>
> return socket_ops::non_blocking_recv(o->socket_,
> bufs.buffers(), bufs.count(), o->flags_,
> (o->state_ & socket_ops::stream_oriented) != 0,
> o->ec_, o->bytes_transferred_);
> }
>
>private:
> socket_type socket_;
> socket_ops::state_type state_;
> MutableBufferSequence buffers_;
> socket_base::message_flags flags_;
>};
>
>template <typename MutableBufferSequence, typename Handler>
>class reactive_socket_recv_op :
> public reactive_socket_recv_op_base<MutableBufferSequence>
>{
>public:
> struct ptr { Handler* h; void* v; reactive_socket_recv_op* p; ~ptr() { reset(); } void reset() { if (p) { p->~reactive_socket_recv_op(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(reactive_socket_recv_op), *h); v = 0; } } };
>
> reactive_socket_recv_op(socket_type socket,
> socket_ops::state_type state, const MutableBufferSequence& buffers,
> socket_base::message_flags flags, Handler& handler)
> : reactive_socket_recv_op_base<MutableBufferSequence>(socket, state,
> buffers, flags, &reactive_socket_recv_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
> static void do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_socket_recv_op* o(static_cast<reactive_socket_recv_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 124 "/usr/include/boost/asio/detail/reactive_socket_recv_op.hpp" 2 3 4
># 30 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_recvmsg_op.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/reactive_socket_recvmsg_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/detail/reactive_socket_recvmsg_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename MutableBufferSequence>
>class reactive_socket_recvmsg_op_base : public reactor_op
>{
>public:
> reactive_socket_recvmsg_op_base(socket_type socket,
> const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags, func_type complete_func)
> : reactor_op(&reactive_socket_recvmsg_op_base::do_perform, complete_func),
> socket_(socket),
> buffers_(buffers),
> in_flags_(in_flags),
> out_flags_(out_flags)
> {
> }
>
> static bool do_perform(reactor_op* base)
> {
> reactive_socket_recvmsg_op_base* o(
> static_cast<reactive_socket_recvmsg_op_base*>(base));
>
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(o->buffers_);
>
> return socket_ops::non_blocking_recvmsg(o->socket_,
> bufs.buffers(), bufs.count(),
> o->in_flags_, o->out_flags_,
> o->ec_, o->bytes_transferred_);
> }
>
>private:
> socket_type socket_;
> MutableBufferSequence buffers_;
> socket_base::message_flags in_flags_;
> socket_base::message_flags& out_flags_;
>};
>
>template <typename MutableBufferSequence, typename Handler>
>class reactive_socket_recvmsg_op :
> public reactive_socket_recvmsg_op_base<MutableBufferSequence>
>{
>public:
> struct ptr { Handler* h; void* v; reactive_socket_recvmsg_op* p; ~ptr() { reset(); } void reset() { if (p) { p->~reactive_socket_recvmsg_op(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(reactive_socket_recvmsg_op), *h); v = 0; } } };
>
> reactive_socket_recvmsg_op(socket_type socket,
> const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags, Handler& handler)
> : reactive_socket_recvmsg_op_base<MutableBufferSequence>(socket, buffers,
> in_flags, out_flags, &reactive_socket_recvmsg_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
> static void do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_socket_recvmsg_op* o(
> static_cast<reactive_socket_recvmsg_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 126 "/usr/include/boost/asio/detail/reactive_socket_recvmsg_op.hpp" 2 3 4
># 31 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_send_op.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/reactive_socket_send_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/reactive_socket_send_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename ConstBufferSequence>
>class reactive_socket_send_op_base : public reactor_op
>{
>public:
> reactive_socket_send_op_base(socket_type socket,
> const ConstBufferSequence& buffers,
> socket_base::message_flags flags, func_type complete_func)
> : reactor_op(&reactive_socket_send_op_base::do_perform, complete_func),
> socket_(socket),
> buffers_(buffers),
> flags_(flags)
> {
> }
>
> static bool do_perform(reactor_op* base)
> {
> reactive_socket_send_op_base* o(
> static_cast<reactive_socket_send_op_base*>(base));
>
> buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence> bufs(o->buffers_);
>
> return socket_ops::non_blocking_send(o->socket_,
> bufs.buffers(), bufs.count(), o->flags_,
> o->ec_, o->bytes_transferred_);
> }
>
>private:
> socket_type socket_;
> ConstBufferSequence buffers_;
> socket_base::message_flags flags_;
>};
>
>template <typename ConstBufferSequence, typename Handler>
>class reactive_socket_send_op :
> public reactive_socket_send_op_base<ConstBufferSequence>
>{
>public:
> struct ptr { Handler* h; void* v; reactive_socket_send_op* p; ~ptr() { reset(); } void reset() { if (p) { p->~reactive_socket_send_op(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(reactive_socket_send_op), *h); v = 0; } } };
>
> reactive_socket_send_op(socket_type socket,
> const ConstBufferSequence& buffers,
> socket_base::message_flags flags, Handler& handler)
> : reactive_socket_send_op_base<ConstBufferSequence>(socket,
> buffers, flags, &reactive_socket_send_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
> static void do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_socket_send_op* o(static_cast<reactive_socket_send_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 121 "/usr/include/boost/asio/detail/reactive_socket_send_op.hpp" 2 3 4
># 32 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 39 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class reactive_socket_service_base
>{
>public:
>
> typedef socket_type native_handle_type;
>
>
> struct base_implementation_type
> {
>
> socket_type socket_;
>
>
> socket_ops::state_type state_;
>
>
> reactor::per_descriptor_data reactor_data_;
> };
>
>
> inline reactive_socket_service_base(
> boost::asio::io_service& io_service);
>
>
> inline void shutdown_service();
>
>
> inline void construct(base_implementation_type& impl);
>
>
> inline void base_move_construct(base_implementation_type& impl,
> base_implementation_type& other_impl);
>
>
> inline void base_move_assign(base_implementation_type& impl,
> reactive_socket_service_base& other_service,
> base_implementation_type& other_impl);
>
>
> inline void destroy(base_implementation_type& impl);
>
>
> bool is_open(const base_implementation_type& impl) const
> {
> return impl.socket_ != invalid_socket;
> }
>
>
> inline boost::system::error_code close(
> base_implementation_type& impl, boost::system::error_code& ec);
>
>
> native_handle_type native_handle(base_implementation_type& impl)
> {
> return impl.socket_;
> }
>
>
> inline boost::system::error_code cancel(
> base_implementation_type& impl, boost::system::error_code& ec);
>
>
> bool at_mark(const base_implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return socket_ops::sockatmark(impl.socket_, ec);
> }
>
>
> std::size_t available(const base_implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return socket_ops::available(impl.socket_, ec);
> }
>
>
> boost::system::error_code listen(base_implementation_type& impl,
> int backlog, boost::system::error_code& ec)
> {
> socket_ops::listen(impl.socket_, backlog, ec);
> return ec;
> }
>
>
> template <typename IO_Control_Command>
> boost::system::error_code io_control(base_implementation_type& impl,
> IO_Control_Command& command, boost::system::error_code& ec)
> {
> socket_ops::ioctl(impl.socket_, impl.state_, command.name(),
> static_cast<ioctl_arg_type*>(command.data()), ec);
> return ec;
> }
>
>
> bool non_blocking(const base_implementation_type& impl) const
> {
> return (impl.state_ & socket_ops::user_set_non_blocking) != 0;
> }
>
>
> boost::system::error_code non_blocking(base_implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> socket_ops::set_user_non_blocking(impl.socket_, impl.state_, mode, ec);
> return ec;
> }
>
>
> bool native_non_blocking(const base_implementation_type& impl) const
> {
> return (impl.state_ & socket_ops::internal_non_blocking) != 0;
> }
>
>
> boost::system::error_code native_non_blocking(base_implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> socket_ops::set_internal_non_blocking(impl.socket_, impl.state_, mode, ec);
> return ec;
> }
>
>
> boost::system::error_code shutdown(base_implementation_type& impl,
> socket_base::shutdown_type what, boost::system::error_code& ec)
> {
> socket_ops::shutdown(impl.socket_, what, ec);
> return ec;
> }
>
>
> template <typename ConstBufferSequence>
> size_t send(base_implementation_type& impl,
> const ConstBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence> bufs(buffers);
>
> return socket_ops::sync_send(impl.socket_, impl.state_,
> bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
> }
>
>
> size_t send(base_implementation_type& impl, const null_buffers&,
> socket_base::message_flags, boost::system::error_code& ec)
> {
>
> socket_ops::poll_write(impl.socket_, impl.state_, ec);
>
> return 0;
> }
>
>
>
> template <typename ConstBufferSequence, typename Handler>
> void async_send(base_implementation_type& impl,
> const ConstBufferSequence& buffers,
> socket_base::message_flags flags, Handler handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_socket_send_op<ConstBufferSequence, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(impl.socket_, buffers, flags, handler);
>
> (void)0;
>
> start_op(impl, reactor::write_op, p.p, is_continuation, true,
> ((impl.state_ & socket_ops::stream_oriented)
> && buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence>::all_empty(buffers)));
> p.v = p.p = 0;
> }
>
>
> template <typename Handler>
> void async_send(base_implementation_type& impl, const null_buffers&,
> socket_base::message_flags, Handler handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_null_buffers_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
> start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>
> template <typename MutableBufferSequence>
> size_t receive(base_implementation_type& impl,
> const MutableBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(buffers);
>
> return socket_ops::sync_recv(impl.socket_, impl.state_,
> bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
> }
>
>
> size_t receive(base_implementation_type& impl, const null_buffers&,
> socket_base::message_flags, boost::system::error_code& ec)
> {
>
> socket_ops::poll_read(impl.socket_, impl.state_, ec);
>
> return 0;
> }
>
>
>
> template <typename MutableBufferSequence, typename Handler>
> void async_receive(base_implementation_type& impl,
> const MutableBufferSequence& buffers,
> socket_base::message_flags flags, Handler handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_socket_recv_op<MutableBufferSequence, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(impl.socket_, impl.state_, buffers, flags, handler);
>
> (void)0;
>
> start_op(impl,
> (flags & socket_base::message_out_of_band)
> ? reactor::except_op : reactor::read_op,
> p.p, is_continuation,
> (flags & socket_base::message_out_of_band) == 0,
> ((impl.state_ & socket_ops::stream_oriented)
> && buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence>::all_empty(buffers)));
> p.v = p.p = 0;
> }
>
>
> template <typename Handler>
> void async_receive(base_implementation_type& impl, const null_buffers&,
> socket_base::message_flags flags, Handler handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_null_buffers_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
> start_op(impl,
> (flags & socket_base::message_out_of_band)
> ? reactor::except_op : reactor::read_op,
> p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>
>
> template <typename MutableBufferSequence>
> size_t receive_with_flags(base_implementation_type& impl,
> const MutableBufferSequence& buffers,
> socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags, boost::system::error_code& ec)
> {
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(buffers);
>
> return socket_ops::sync_recvmsg(impl.socket_, impl.state_,
> bufs.buffers(), bufs.count(), in_flags, out_flags, ec);
> }
>
>
> size_t receive_with_flags(base_implementation_type& impl,
> const null_buffers&, socket_base::message_flags,
> socket_base::message_flags& out_flags, boost::system::error_code& ec)
> {
>
> socket_ops::poll_read(impl.socket_, impl.state_, ec);
>
>
>
> out_flags = 0;
>
> return 0;
> }
>
>
>
> template <typename MutableBufferSequence, typename Handler>
> void async_receive_with_flags(base_implementation_type& impl,
> const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags, Handler handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_socket_recvmsg_op<MutableBufferSequence, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(impl.socket_, buffers, in_flags, out_flags, handler);
>
> (void)0
> ;
>
> start_op(impl,
> (in_flags & socket_base::message_out_of_band)
> ? reactor::except_op : reactor::read_op,
> p.p, is_continuation,
> (in_flags & socket_base::message_out_of_band) == 0, false);
> p.v = p.p = 0;
> }
>
>
> template <typename Handler>
> void async_receive_with_flags(base_implementation_type& impl,
> const null_buffers&, socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags, Handler handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_null_buffers_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
>
>
> out_flags = 0;
>
> start_op(impl,
> (in_flags & socket_base::message_out_of_band)
> ? reactor::except_op : reactor::read_op,
> p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>protected:
>
> inline boost::system::error_code do_open(
> base_implementation_type& impl, int af,
> int type, int protocol, boost::system::error_code& ec);
>
>
> inline boost::system::error_code do_assign(
> base_implementation_type& impl, int type,
> const native_handle_type& native_socket, boost::system::error_code& ec);
>
>
> inline void start_op(base_implementation_type& impl, int op_type,
> reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop);
>
>
> inline void start_accept_op(base_implementation_type& impl,
> reactor_op* op, bool is_continuation, bool peer_is_open);
>
>
> inline void start_connect_op(base_implementation_type& impl,
> reactor_op* op, bool is_continuation,
> const socket_addr_type* addr, size_t addrlen);
>
>
> reactor& reactor_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 443 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 1 3 4
># 22 "/usr/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>reactive_socket_service_base::reactive_socket_service_base(
> boost::asio::io_service& io_service)
> : reactor_(use_service<reactor>(io_service))
>{
> reactor_.init_task();
>}
>
>void reactive_socket_service_base::shutdown_service()
>{
>}
>
>void reactive_socket_service_base::construct(
> reactive_socket_service_base::base_implementation_type& impl)
>{
> impl.socket_ = invalid_socket;
> impl.state_ = 0;
>}
>
>void reactive_socket_service_base::base_move_construct(
> reactive_socket_service_base::base_implementation_type& impl,
> reactive_socket_service_base::base_implementation_type& other_impl)
>{
> impl.socket_ = other_impl.socket_;
> other_impl.socket_ = invalid_socket;
>
> impl.state_ = other_impl.state_;
> other_impl.state_ = 0;
>
> reactor_.move_descriptor(impl.socket_,
> impl.reactor_data_, other_impl.reactor_data_);
>}
>
>void reactive_socket_service_base::base_move_assign(
> reactive_socket_service_base::base_implementation_type& impl,
> reactive_socket_service_base& other_service,
> reactive_socket_service_base::base_implementation_type& other_impl)
>{
> destroy(impl);
>
> impl.socket_ = other_impl.socket_;
> other_impl.socket_ = invalid_socket;
>
> impl.state_ = other_impl.state_;
> other_impl.state_ = 0;
>
> other_service.reactor_.move_descriptor(impl.socket_,
> impl.reactor_data_, other_impl.reactor_data_);
>}
>
>void reactive_socket_service_base::destroy(
> reactive_socket_service_base::base_implementation_type& impl)
>{
> if (impl.socket_ != invalid_socket)
> {
> (void)0;
>
> reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_,
> (impl.state_ & socket_ops::possible_dup) == 0);
>
> boost::system::error_code ignored_ec;
> socket_ops::close(impl.socket_, impl.state_, true, ignored_ec);
> }
>}
>
>boost::system::error_code reactive_socket_service_base::close(
> reactive_socket_service_base::base_implementation_type& impl,
> boost::system::error_code& ec)
>{
> if (is_open(impl))
> {
> (void)0;
>
> reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_,
> (impl.state_ & socket_ops::possible_dup) == 0);
> }
>
> socket_ops::close(impl.socket_, impl.state_, false, ec);
># 116 "/usr/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 3 4
> construct(impl);
>
> return ec;
>}
>
>boost::system::error_code reactive_socket_service_base::cancel(
> reactive_socket_service_base::base_implementation_type& impl,
> boost::system::error_code& ec)
>{
> if (!is_open(impl))
> {
> ec = boost::asio::error::bad_descriptor;
> return ec;
> }
>
> (void)0;
>
> reactor_.cancel_ops(impl.socket_, impl.reactor_data_);
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code reactive_socket_service_base::do_open(
> reactive_socket_service_base::base_implementation_type& impl,
> int af, int type, int protocol, boost::system::error_code& ec)
>{
> if (is_open(impl))
> {
> ec = boost::asio::error::already_open;
> return ec;
> }
>
> socket_holder sock(socket_ops::socket(af, type, protocol, ec));
> if (sock.get() == invalid_socket)
> return ec;
>
> if (int err = reactor_.register_descriptor(sock.get(), impl.reactor_data_))
> {
> ec = boost::system::error_code(err,
> boost::asio::error::get_system_category());
> return ec;
> }
>
> impl.socket_ = sock.release();
> switch (type)
> {
> case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
> case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
> default: impl.state_ = 0; break;
> }
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code reactive_socket_service_base::do_assign(
> reactive_socket_service_base::base_implementation_type& impl, int type,
> const reactive_socket_service_base::native_handle_type& native_socket,
> boost::system::error_code& ec)
>{
> if (is_open(impl))
> {
> ec = boost::asio::error::already_open;
> return ec;
> }
>
> if (int err = reactor_.register_descriptor(
> native_socket, impl.reactor_data_))
> {
> ec = boost::system::error_code(err,
> boost::asio::error::get_system_category());
> return ec;
> }
>
> impl.socket_ = native_socket;
> switch (type)
> {
> case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
> case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
> default: impl.state_ = 0; break;
> }
> impl.state_ |= socket_ops::possible_dup;
> ec = boost::system::error_code();
> return ec;
>}
>
>void reactive_socket_service_base::start_op(
> reactive_socket_service_base::base_implementation_type& impl,
> int op_type, reactor_op* op, bool is_continuation,
> bool is_non_blocking, bool noop)
>{
> if (!noop)
> {
> if ((impl.state_ & socket_ops::non_blocking)
> || socket_ops::set_internal_non_blocking(
> impl.socket_, impl.state_, true, op->ec_))
> {
> reactor_.start_op(op_type, impl.socket_,
> impl.reactor_data_, op, is_continuation, is_non_blocking);
> return;
> }
> }
>
> reactor_.post_immediate_completion(op, is_continuation);
>}
>
>void reactive_socket_service_base::start_accept_op(
> reactive_socket_service_base::base_implementation_type& impl,
> reactor_op* op, bool is_continuation, bool peer_is_open)
>{
> if (!peer_is_open)
> start_op(impl, reactor::read_op, op, true, is_continuation, false);
> else
> {
> op->ec_ = boost::asio::error::already_open;
> reactor_.post_immediate_completion(op, is_continuation);
> }
>}
>
>void reactive_socket_service_base::start_connect_op(
> reactive_socket_service_base::base_implementation_type& impl,
> reactor_op* op, bool is_continuation,
> const socket_addr_type* addr, size_t addrlen)
>{
> if ((impl.state_ & socket_ops::non_blocking)
> || socket_ops::set_internal_non_blocking(
> impl.socket_, impl.state_, true, op->ec_))
> {
> if (socket_ops::connect(impl.socket_, addr, addrlen, op->ec_) != 0)
> {
> if (op->ec_ == boost::asio::error::in_progress
> || op->ec_ == boost::asio::error::would_block)
> {
> op->ec_ = boost::system::error_code();
> reactor_.start_op(reactor::connect_op, impl.socket_,
> impl.reactor_data_, op, is_continuation, false);
> return;
> }
> }
> }
>
> reactor_.post_immediate_completion(op, is_continuation);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 264 "/usr/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 2 3 4
># 446 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
># 35 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 42 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Protocol>
>class reactive_socket_service :
> public reactive_socket_service_base
>{
>public:
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
>
>
> typedef socket_type native_handle_type;
>
>
> struct implementation_type :
> reactive_socket_service_base::base_implementation_type
> {
>
> implementation_type()
> : protocol_(endpoint_type().protocol())
> {
> }
>
>
> protocol_type protocol_;
> };
>
>
> reactive_socket_service(boost::asio::io_service& io_service)
> : reactive_socket_service_base(io_service)
> {
> }
>
>
> void move_construct(implementation_type& impl,
> implementation_type& other_impl)
> {
> this->base_move_construct(impl, other_impl);
>
> impl.protocol_ = other_impl.protocol_;
> other_impl.protocol_ = endpoint_type().protocol();
> }
>
>
> void move_assign(implementation_type& impl,
> reactive_socket_service_base& other_service,
> implementation_type& other_impl)
> {
> this->base_move_assign(impl, other_service, other_impl);
>
> impl.protocol_ = other_impl.protocol_;
> other_impl.protocol_ = endpoint_type().protocol();
> }
>
>
> template <typename Protocol1>
> void converting_move_construct(implementation_type& impl,
> typename reactive_socket_service<
> Protocol1>::implementation_type& other_impl)
> {
> this->base_move_construct(impl, other_impl);
>
> impl.protocol_ = protocol_type(other_impl.protocol_);
> other_impl.protocol_ = typename Protocol1::endpoint().protocol();
> }
>
>
> boost::system::error_code open(implementation_type& impl,
> const protocol_type& protocol, boost::system::error_code& ec)
> {
> if (!do_open(impl, protocol.family(),
> protocol.type(), protocol.protocol(), ec))
> impl.protocol_ = protocol;
> return ec;
> }
>
>
> boost::system::error_code assign(implementation_type& impl,
> const protocol_type& protocol, const native_handle_type& native_socket,
> boost::system::error_code& ec)
> {
> if (!do_assign(impl, protocol.type(), native_socket, ec))
> impl.protocol_ = protocol;
> return ec;
> }
>
>
> native_handle_type native_handle(implementation_type& impl)
> {
> return impl.socket_;
> }
>
>
> boost::system::error_code bind(implementation_type& impl,
> const endpoint_type& endpoint, boost::system::error_code& ec)
> {
> socket_ops::bind(impl.socket_, endpoint.data(), endpoint.size(), ec);
> return ec;
> }
>
>
> template <typename Option>
> boost::system::error_code set_option(implementation_type& impl,
> const Option& option, boost::system::error_code& ec)
> {
> socket_ops::setsockopt(impl.socket_, impl.state_,
> option.level(impl.protocol_), option.name(impl.protocol_),
> option.data(impl.protocol_), option.size(impl.protocol_), ec);
> return ec;
> }
>
>
> template <typename Option>
> boost::system::error_code get_option(const implementation_type& impl,
> Option& option, boost::system::error_code& ec) const
> {
> std::size_t size = option.size(impl.protocol_);
> socket_ops::getsockopt(impl.socket_, impl.state_,
> option.level(impl.protocol_), option.name(impl.protocol_),
> option.data(impl.protocol_), &size, ec);
> if (!ec)
> option.resize(impl.protocol_, size);
> return ec;
> }
>
>
> endpoint_type local_endpoint(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> endpoint_type endpoint;
> std::size_t addr_len = endpoint.capacity();
> if (socket_ops::getsockname(impl.socket_, endpoint.data(), &addr_len, ec))
> return endpoint_type();
> endpoint.resize(addr_len);
> return endpoint;
> }
>
>
> endpoint_type remote_endpoint(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> endpoint_type endpoint;
> std::size_t addr_len = endpoint.capacity();
> if (socket_ops::getpeername(impl.socket_,
> endpoint.data(), &addr_len, false, ec))
> return endpoint_type();
> endpoint.resize(addr_len);
> return endpoint;
> }
>
>
>
> template <typename ConstBufferSequence>
> size_t send_to(implementation_type& impl, const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags,
> boost::system::error_code& ec)
> {
> buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence> bufs(buffers);
>
> return socket_ops::sync_sendto(impl.socket_, impl.state_,
> bufs.buffers(), bufs.count(), flags,
> destination.data(), destination.size(), ec);
> }
>
>
> size_t send_to(implementation_type& impl, const null_buffers&,
> const endpoint_type&, socket_base::message_flags,
> boost::system::error_code& ec)
> {
>
> socket_ops::poll_write(impl.socket_, impl.state_, ec);
>
> return 0;
> }
>
>
>
> template <typename ConstBufferSequence, typename Handler>
> void async_send_to(implementation_type& impl,
> const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags,
> Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_socket_sendto_op<ConstBufferSequence,
> endpoint_type, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(impl.socket_, buffers, destination, flags, handler);
>
> (void)0;
>
> start_op(impl, reactor::write_op, p.p, is_continuation, true, false);
> p.v = p.p = 0;
> }
>
>
> template <typename Handler>
> void async_send_to(implementation_type& impl, const null_buffers&,
> const endpoint_type&, socket_base::message_flags, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_null_buffers_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
> start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>
>
> template <typename MutableBufferSequence>
> size_t receive_from(implementation_type& impl,
> const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint, socket_base::message_flags flags,
> boost::system::error_code& ec)
> {
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(buffers);
>
> std::size_t addr_len = sender_endpoint.capacity();
> std::size_t bytes_recvd = socket_ops::sync_recvfrom(
> impl.socket_, impl.state_, bufs.buffers(), bufs.count(),
> flags, sender_endpoint.data(), &addr_len, ec);
>
> if (!ec)
> sender_endpoint.resize(addr_len);
>
> return bytes_recvd;
> }
>
>
> size_t receive_from(implementation_type& impl, const null_buffers&,
> endpoint_type& sender_endpoint, socket_base::message_flags,
> boost::system::error_code& ec)
> {
>
> socket_ops::poll_read(impl.socket_, impl.state_, ec);
>
>
> sender_endpoint = endpoint_type();
>
> return 0;
> }
>
>
>
>
> template <typename MutableBufferSequence, typename Handler>
> void async_receive_from(implementation_type& impl,
> const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
> socket_base::message_flags flags, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_socket_recvfrom_op<MutableBufferSequence,
> endpoint_type, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> int protocol = impl.protocol_.type();
> p.p = new (p.v) op(impl.socket_, protocol,
> buffers, sender_endpoint, flags, handler);
>
> (void)0
> ;
>
> start_op(impl,
> (flags & socket_base::message_out_of_band)
> ? reactor::except_op : reactor::read_op,
> p.p, is_continuation, true, false);
> p.v = p.p = 0;
> }
>
>
> template <typename Handler>
> void async_receive_from(implementation_type& impl,
> const null_buffers&, endpoint_type& sender_endpoint,
> socket_base::message_flags flags, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_null_buffers_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
>
> sender_endpoint = endpoint_type();
>
> start_op(impl,
> (flags & socket_base::message_out_of_band)
> ? reactor::except_op : reactor::read_op,
> p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>
> template <typename Socket>
> boost::system::error_code accept(implementation_type& impl,
> Socket& peer, endpoint_type* peer_endpoint, boost::system::error_code& ec)
> {
>
> if (peer.is_open())
> {
> ec = boost::asio::error::already_open;
> return ec;
> }
>
> std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0;
> socket_holder new_socket(socket_ops::sync_accept(impl.socket_,
> impl.state_, peer_endpoint ? peer_endpoint->data() : 0,
> peer_endpoint ? &addr_len : 0, ec));
>
>
> if (new_socket.get() != invalid_socket)
> {
> if (peer_endpoint)
> peer_endpoint->resize(addr_len);
> if (!peer.assign(impl.protocol_, new_socket.get(), ec))
> new_socket.release();
> }
>
> return ec;
> }
>
>
>
> template <typename Socket, typename Handler>
> void async_accept(implementation_type& impl, Socket& peer,
> endpoint_type* peer_endpoint, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_socket_accept_op<Socket, Protocol, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(impl.socket_, impl.state_, peer,
> impl.protocol_, peer_endpoint, handler);
>
> (void)0;
>
> start_accept_op(impl, p.p, is_continuation, peer.is_open());
> p.v = p.p = 0;
> }
>
>
> boost::system::error_code connect(implementation_type& impl,
> const endpoint_type& peer_endpoint, boost::system::error_code& ec)
> {
> socket_ops::sync_connect(impl.socket_,
> peer_endpoint.data(), peer_endpoint.size(), ec);
> return ec;
> }
>
>
> template <typename Handler>
> void async_connect(implementation_type& impl,
> const endpoint_type& peer_endpoint, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_socket_connect_op<Protocol, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(impl.socket_, peer_endpoint, handler);
>
> (void)0;
>
> start_connect_op(impl, p.p, is_continuation,
> peer_endpoint.data(), peer_endpoint.size());
> p.v = p.p = 0;
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 456 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
># 29 "/usr/include/boost/asio/datagram_socket_service.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 32 "/usr/include/boost/asio/datagram_socket_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>template <typename Protocol>
>class datagram_socket_service
>
>
>
> : public boost::asio::detail::service_base<datagram_socket_service<Protocol> >
>
>{
>public:
>
>
>
>
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
>
>private:
>
>
>
>
> typedef detail::reactive_socket_service<Protocol> service_impl_type;
>
>
>public:
>
>
>
>
> typedef typename service_impl_type::implementation_type implementation_type;
>
>
>
>
>
>
> typedef typename service_impl_type::native_handle_type native_type;
>
>
>
>
>
>
> typedef typename service_impl_type::native_handle_type native_handle_type;
>
>
>
> explicit datagram_socket_service(boost::asio::io_service& io_service)
> : boost::asio::detail::service_base<
> datagram_socket_service<Protocol> >(io_service),
> service_impl_(io_service)
> {
> }
>
>
> void construct(implementation_type& impl)
> {
> service_impl_.construct(impl);
> }
>
>
>
> void move_construct(implementation_type& impl,
> implementation_type& other_impl)
> {
> service_impl_.move_construct(impl, other_impl);
> }
>
>
> void move_assign(implementation_type& impl,
> datagram_socket_service& other_service,
> implementation_type& other_impl)
> {
> service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
> }
>
>
>
> template <typename Protocol1>
> void converting_move_construct(implementation_type& impl,
> typename datagram_socket_service<
> Protocol1>::implementation_type& other_impl,
> typename enable_if<is_convertible<
> Protocol1, Protocol>::value>::type* = 0)
> {
> service_impl_.template converting_move_construct<Protocol1>(
> impl, other_impl);
> }
>
>
>
> void destroy(implementation_type& impl)
> {
> service_impl_.destroy(impl);
> }
>
>
> boost::system::error_code open(implementation_type& impl,
> const protocol_type& protocol, boost::system::error_code& ec)
> {
> if (protocol.type() == SOCK_DGRAM)
> service_impl_.open(impl, protocol, ec);
> else
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
>
>
> boost::system::error_code assign(implementation_type& impl,
> const protocol_type& protocol, const native_handle_type& native_socket,
> boost::system::error_code& ec)
> {
> return service_impl_.assign(impl, protocol, native_socket, ec);
> }
>
>
> bool is_open(const implementation_type& impl) const
> {
> return service_impl_.is_open(impl);
> }
>
>
> boost::system::error_code close(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.close(impl, ec);
> }
>
>
> native_type native(implementation_type& impl)
> {
> return service_impl_.native_handle(impl);
> }
>
>
> native_handle_type native_handle(implementation_type& impl)
> {
> return service_impl_.native_handle(impl);
> }
>
>
> boost::system::error_code cancel(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.cancel(impl, ec);
> }
>
>
> bool at_mark(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.at_mark(impl, ec);
> }
>
>
> std::size_t available(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.available(impl, ec);
> }
>
>
> boost::system::error_code bind(implementation_type& impl,
> const endpoint_type& endpoint, boost::system::error_code& ec)
> {
> return service_impl_.bind(impl, endpoint, ec);
> }
>
>
> boost::system::error_code connect(implementation_type& impl,
> const endpoint_type& peer_endpoint, boost::system::error_code& ec)
> {
> return service_impl_.connect(impl, peer_endpoint, ec);
> }
>
>
> template <typename ConnectHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
>
> async_connect(implementation_type& impl,
> const endpoint_type& peer_endpoint,
> ConnectHandler&& handler)
> {
> detail::async_result_init<
> ConnectHandler, void (boost::system::error_code)> init(
> static_cast<ConnectHandler&&>(handler));
>
> service_impl_.async_connect(impl, peer_endpoint, init.handler);
>
> return init.result.get();
> }
>
>
> template <typename SettableSocketOption>
> boost::system::error_code set_option(implementation_type& impl,
> const SettableSocketOption& option, boost::system::error_code& ec)
> {
> return service_impl_.set_option(impl, option, ec);
> }
>
>
> template <typename GettableSocketOption>
> boost::system::error_code get_option(const implementation_type& impl,
> GettableSocketOption& option, boost::system::error_code& ec) const
> {
> return service_impl_.get_option(impl, option, ec);
> }
>
>
> template <typename IoControlCommand>
> boost::system::error_code io_control(implementation_type& impl,
> IoControlCommand& command, boost::system::error_code& ec)
> {
> return service_impl_.io_control(impl, command, ec);
> }
>
>
> bool non_blocking(const implementation_type& impl) const
> {
> return service_impl_.non_blocking(impl);
> }
>
>
> boost::system::error_code non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> return service_impl_.non_blocking(impl, mode, ec);
> }
>
>
> bool native_non_blocking(const implementation_type& impl) const
> {
> return service_impl_.native_non_blocking(impl);
> }
>
>
> boost::system::error_code native_non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> return service_impl_.native_non_blocking(impl, mode, ec);
> }
>
>
> endpoint_type local_endpoint(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.local_endpoint(impl, ec);
> }
>
>
> endpoint_type remote_endpoint(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.remote_endpoint(impl, ec);
> }
>
>
> boost::system::error_code shutdown(implementation_type& impl,
> socket_base::shutdown_type what, boost::system::error_code& ec)
> {
> return service_impl_.shutdown(impl, what, ec);
> }
>
>
> template <typename ConstBufferSequence>
> std::size_t send(implementation_type& impl,
> const ConstBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return service_impl_.send(impl, buffers, flags, ec);
> }
>
>
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send(implementation_type& impl, const ConstBufferSequence& buffers,
> socket_base::message_flags flags,
> WriteHandler&& handler)
> {
> detail::async_result_init<
> WriteHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<WriteHandler&&>(handler));
>
> service_impl_.async_send(impl, buffers, flags, init.handler);
>
> return init.result.get();
> }
>
>
> template <typename ConstBufferSequence>
> std::size_t send_to(implementation_type& impl,
> const ConstBufferSequence& buffers, const endpoint_type& destination,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return service_impl_.send_to(impl, buffers, destination, flags, ec);
> }
>
>
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send_to(implementation_type& impl,
> const ConstBufferSequence& buffers, const endpoint_type& destination,
> socket_base::message_flags flags,
> WriteHandler&& handler)
> {
> detail::async_result_init<
> WriteHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<WriteHandler&&>(handler));
>
> service_impl_.async_send_to(impl, buffers,
> destination, flags, init.handler);
>
> return init.result.get();
> }
>
>
> template <typename MutableBufferSequence>
> std::size_t receive(implementation_type& impl,
> const MutableBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return service_impl_.receive(impl, buffers, flags, ec);
> }
>
>
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive(implementation_type& impl,
> const MutableBufferSequence& buffers,
> socket_base::message_flags flags,
> ReadHandler&& handler)
> {
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> service_impl_.async_receive(impl, buffers, flags, init.handler);
>
> return init.result.get();
> }
>
>
> template <typename MutableBufferSequence>
> std::size_t receive_from(implementation_type& impl,
> const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return service_impl_.receive_from(impl, buffers, sender_endpoint, flags,
> ec);
> }
>
>
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive_from(implementation_type& impl,
> const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
> socket_base::message_flags flags,
> ReadHandler&& handler)
> {
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> service_impl_.async_receive_from(impl, buffers,
> sender_endpoint, flags, init.handler);
>
> return init.result.get();
> }
>
>private:
>
> void shutdown_service()
> {
> service_impl_.shutdown_service();
> }
>
>
> service_impl_type service_impl_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 429 "/usr/include/boost/asio/datagram_socket_service.hpp" 2 3 4
># 22 "/usr/include/boost/asio/basic_datagram_socket.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/basic_datagram_socket.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 41 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
>template <typename Protocol,
> typename DatagramSocketService = datagram_socket_service<Protocol> >
>class basic_datagram_socket
> : public basic_socket<Protocol, DatagramSocketService>
>{
>public:
>
>
> typedef typename DatagramSocketService::native_handle_type native_type;
>
>
> typedef typename DatagramSocketService::native_handle_type native_handle_type;
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
># 69 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> explicit basic_datagram_socket(boost::asio::io_service& io_service)
> : basic_socket<Protocol, DatagramSocketService>(io_service)
> {
> }
># 86 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> basic_datagram_socket(boost::asio::io_service& io_service,
> const protocol_type& protocol)
> : basic_socket<Protocol, DatagramSocketService>(io_service, protocol)
> {
> }
># 108 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> basic_datagram_socket(boost::asio::io_service& io_service,
> const endpoint_type& endpoint)
> : basic_socket<Protocol, DatagramSocketService>(io_service, endpoint)
> {
> }
># 129 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> basic_datagram_socket(boost::asio::io_service& io_service,
> const protocol_type& protocol, const native_handle_type& native_socket)
> : basic_socket<Protocol, DatagramSocketService>(
> io_service, protocol, native_socket)
> {
> }
># 147 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> basic_datagram_socket(basic_datagram_socket&& other)
> : basic_socket<Protocol, DatagramSocketService>(
> static_cast<basic_datagram_socket&&>(other))
> {
> }
># 164 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> basic_datagram_socket& operator=(basic_datagram_socket&& other)
> {
> basic_socket<Protocol, DatagramSocketService>::operator=(
> static_cast<basic_datagram_socket&&>(other));
> return *this;
> }
># 182 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename Protocol1, typename DatagramSocketService1>
> basic_datagram_socket(
> basic_datagram_socket<Protocol1, DatagramSocketService1>&& other,
> typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
> : basic_socket<Protocol, DatagramSocketService>(
> static_cast<basic_datagram_socket< Protocol1, DatagramSocketService1>&&>
> (other))
> {
> }
># 204 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename Protocol1, typename DatagramSocketService1>
> typename enable_if<is_convertible<Protocol1, Protocol>::value,
> basic_datagram_socket>::type& operator=(
> basic_datagram_socket<Protocol1, DatagramSocketService1>&& other)
> {
> basic_socket<Protocol, DatagramSocketService>::operator=(
> static_cast<basic_datagram_socket< Protocol1, DatagramSocketService1>&&>
> (other));
> return *this;
> }
># 238 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "send");
> return s;
> }
># 265 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> boost::asio::detail::throw_error(ec, "send");
> return s;
> }
># 293 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> }
># 337 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send(const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_send(this->get_implementation(),
> buffers, 0, static_cast<WriteHandler&&>(handler));
> }
># 380 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags,
> WriteHandler&& handler)
> {
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_send(this->get_implementation(),
> buffers, flags, static_cast<WriteHandler&&>(handler));
> }
># 420 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send_to(
> this->get_implementation(), buffers, destination, 0, ec);
> boost::asio::detail::throw_error(ec, "send_to");
> return s;
> }
># 447 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send_to(
> this->get_implementation(), buffers, destination, flags, ec);
> boost::asio::detail::throw_error(ec, "send_to");
> return s;
> }
># 474 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags,
> boost::system::error_code& ec)
> {
> return this->get_service().send_to(this->get_implementation(),
> buffers, destination, flags, ec);
> }
># 520 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination,
> WriteHandler&& handler)
> {
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_send_to(
> this->get_implementation(), buffers, destination, 0,
> static_cast<WriteHandler&&>(handler));
> }
># 563 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags,
> WriteHandler&& handler)
> {
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_send_to(
> this->get_implementation(), buffers, destination, flags,
> static_cast<WriteHandler&&>(handler));
> }
># 603 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 631 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, flags, ec);
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 660 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return this->get_service().receive(
> this->get_implementation(), buffers, flags, ec);
> }
># 704 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive(const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_receive(this->get_implementation(),
> buffers, 0, static_cast<ReadHandler&&>(handler));
> }
># 746 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags,
> ReadHandler&& handler)
> {
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_receive(this->get_implementation(),
> buffers, flags, static_cast<ReadHandler&&>(handler));
> }
># 787 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive_from(
> this->get_implementation(), buffers, sender_endpoint, 0, ec);
> boost::asio::detail::throw_error(ec, "receive_from");
> return s;
> }
># 814 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint, socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive_from(
> this->get_implementation(), buffers, sender_endpoint, flags, ec);
> boost::asio::detail::throw_error(ec, "receive_from");
> return s;
> }
># 841 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint, socket_base::message_flags flags,
> boost::system::error_code& ec)
> {
> return this->get_service().receive_from(this->get_implementation(),
> buffers, sender_endpoint, flags, ec);
> }
># 886 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint,
> ReadHandler&& handler)
> {
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_receive_from(
> this->get_implementation(), buffers, sender_endpoint, 0,
> static_cast<ReadHandler&&>(handler));
> }
># 931 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint, socket_base::message_flags flags,
> ReadHandler&& handler)
> {
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_receive_from(
> this->get_implementation(), buffers, sender_endpoint, flags,
> static_cast<ReadHandler&&>(handler));
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 952 "/usr/include/boost/asio/basic_datagram_socket.hpp" 2 3 4
># 22 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_deadline_timer.hpp" 1 3 4
># 23 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 24 "/usr/include/boost/asio/basic_deadline_timer.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/deadline_timer_service.hpp" 1 3 4
># 23 "/usr/include/boost/asio/deadline_timer_service.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 24 "/usr/include/boost/asio/deadline_timer_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
># 28 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/timer_queue.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/timer_queue.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/detail/timer_queue.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/date_time_fwd.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/date_time_fwd.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>template<class T, class TimeSystem>
>class base_time;
>
>}
>namespace posix_time {
>
>class ptime;
>
>}
>}
># 23 "/usr/include/boost/asio/detail/timer_queue.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 30 "/usr/include/boost/asio/detail/timer_queue.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Time_Traits>
>class timer_queue
> : public timer_queue_base
>{
>public:
>
> typedef typename Time_Traits::time_type time_type;
>
>
> typedef typename Time_Traits::duration_type duration_type;
>
>
> class per_timer_data
> {
> public:
> per_timer_data() : next_(0), prev_(0) {}
>
> private:
> friend class timer_queue;
>
>
> op_queue<wait_op> op_queue_;
>
>
> std::size_t heap_index_;
>
>
> per_timer_data* next_;
> per_timer_data* prev_;
> };
>
>
> timer_queue()
> : timers_(),
> heap_()
> {
> }
>
>
>
>
> bool enqueue_timer(const time_type& time, per_timer_data& timer, wait_op* op)
> {
>
> if (timer.prev_ == 0 && &timer != timers_)
> {
> if (this->is_positive_infinity(time))
> {
>
> timer.heap_index_ = (std::numeric_limits<std::size_t>::max)();
> }
> else
> {
>
>
> timer.heap_index_ = heap_.size();
> heap_entry entry = { time, &timer };
> heap_.push_back(entry);
> up_heap(heap_.size() - 1);
> }
>
>
> timer.next_ = timers_;
> timer.prev_ = 0;
> if (timers_)
> timers_->prev_ = &timer;
> timers_ = &timer;
> }
>
>
> timer.op_queue_.push(op);
>
>
> return timer.heap_index_ == 0 && timer.op_queue_.front() == op;
> }
>
>
> virtual bool empty() const
> {
> return timers_ == 0;
> }
>
>
> virtual long wait_duration_msec(long max_duration) const
> {
> if (heap_.empty())
> return max_duration;
>
> return this->to_msec(
> Time_Traits::to_posix_duration(
> Time_Traits::subtract(heap_[0].time_, Time_Traits::now())),
> max_duration);
> }
>
>
> virtual long wait_duration_usec(long max_duration) const
> {
> if (heap_.empty())
> return max_duration;
>
> return this->to_usec(
> Time_Traits::to_posix_duration(
> Time_Traits::subtract(heap_[0].time_, Time_Traits::now())),
> max_duration);
> }
>
>
> virtual void get_ready_timers(op_queue<operation>& ops)
> {
> if (!heap_.empty())
> {
> const time_type now = Time_Traits::now();
> while (!heap_.empty() && !Time_Traits::less_than(now, heap_[0].time_))
> {
> per_timer_data* timer = heap_[0].timer_;
> ops.push(timer->op_queue_);
> remove_timer(*timer);
> }
> }
> }
>
>
> virtual void get_all_timers(op_queue<operation>& ops)
> {
> while (timers_)
> {
> per_timer_data* timer = timers_;
> timers_ = timers_->next_;
> ops.push(timer->op_queue_);
> timer->next_ = 0;
> timer->prev_ = 0;
> }
>
> heap_.clear();
> }
>
>
> std::size_t cancel_timer(per_timer_data& timer, op_queue<operation>& ops,
> std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)())
> {
> std::size_t num_cancelled = 0;
> if (timer.prev_ != 0 || &timer == timers_)
> {
> while (wait_op* op = (num_cancelled != max_cancelled)
> ? timer.op_queue_.front() : 0)
> {
> op->ec_ = boost::asio::error::operation_aborted;
> timer.op_queue_.pop();
> ops.push(op);
> ++num_cancelled;
> }
> if (timer.op_queue_.empty())
> remove_timer(timer);
> }
> return num_cancelled;
> }
>
>private:
>
> void up_heap(std::size_t index)
> {
> std::size_t parent = (index - 1) / 2;
> while (index > 0
> && Time_Traits::less_than(heap_[index].time_, heap_[parent].time_))
> {
> swap_heap(index, parent);
> index = parent;
> parent = (index - 1) / 2;
> }
> }
>
>
> void down_heap(std::size_t index)
> {
> std::size_t child = index * 2 + 1;
> while (child < heap_.size())
> {
> std::size_t min_child = (child + 1 == heap_.size()
> || Time_Traits::less_than(
> heap_[child].time_, heap_[child + 1].time_))
> ? child : child + 1;
> if (Time_Traits::less_than(heap_[index].time_, heap_[min_child].time_))
> break;
> swap_heap(index, min_child);
> index = min_child;
> child = index * 2 + 1;
> }
> }
>
>
> void swap_heap(std::size_t index1, std::size_t index2)
> {
> heap_entry tmp = heap_[index1];
> heap_[index1] = heap_[index2];
> heap_[index2] = tmp;
> heap_[index1].timer_->heap_index_ = index1;
> heap_[index2].timer_->heap_index_ = index2;
> }
>
>
> void remove_timer(per_timer_data& timer)
> {
>
> std::size_t index = timer.heap_index_;
> if (!heap_.empty() && index < heap_.size())
> {
> if (index == heap_.size() - 1)
> {
> heap_.pop_back();
> }
> else
> {
> swap_heap(index, heap_.size() - 1);
> heap_.pop_back();
> std::size_t parent = (index - 1) / 2;
> if (index > 0 && Time_Traits::less_than(
> heap_[index].time_, heap_[parent].time_))
> up_heap(index);
> else
> down_heap(index);
> }
> }
>
>
> if (timers_ == &timer)
> timers_ = timer.next_;
> if (timer.prev_)
> timer.prev_->next_ = timer.next_;
> if (timer.next_)
> timer.next_->prev_= timer.prev_;
> timer.next_ = 0;
> timer.prev_ = 0;
> }
>
>
> template <typename Time_Type>
> static bool is_positive_infinity(const Time_Type&)
> {
> return false;
> }
>
>
> template <typename T, typename TimeSystem>
> static bool is_positive_infinity(
> const boost::date_time::base_time<T, TimeSystem>& time)
> {
> return time.is_pos_infinity();
> }
>
>
> template <typename Duration>
> long to_msec(const Duration& d, long max_duration) const
> {
> if (d.ticks() <= 0)
> return 0;
> int64_t msec = d.total_milliseconds();
> if (msec == 0)
> return 1;
> if (msec > max_duration)
> return max_duration;
> return static_cast<long>(msec);
> }
>
>
> template <typename Duration>
> long to_usec(const Duration& d, long max_duration) const
> {
> if (d.ticks() <= 0)
> return 0;
> int64_t usec = d.total_microseconds();
> if (usec == 0)
> return 1;
> if (usec > max_duration)
> return max_duration;
> return static_cast<long>(usec);
> }
>
>
> per_timer_data* timers_;
>
> struct heap_entry
> {
>
> time_type time_;
>
>
> per_timer_data* timer_;
> };
>
>
> std::vector<heap_entry> heap_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 333 "/usr/include/boost/asio/detail/timer_queue.hpp" 2 3 4
># 29 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/timer_scheduler.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/timer_scheduler.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/timer_scheduler_fwd.hpp" 1 3 4
># 32 "/usr/include/boost/asio/detail/timer_scheduler_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>typedef epoll_reactor timer_scheduler;
># 48 "/usr/include/boost/asio/detail/timer_scheduler_fwd.hpp" 3 4
>}
>}
>}
># 20 "/usr/include/boost/asio/detail/timer_scheduler.hpp" 2 3 4
># 30 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/wait_handler.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/wait_handler.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/wait_handler.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Handler>
>class wait_handler : public wait_op
>{
>public:
> struct ptr { Handler* h; void* v; wait_handler* p; ~ptr() { reset(); } void reset() { if (p) { p->~wait_handler(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(wait_handler), *h); v = 0; } } };
>
> wait_handler(Handler& h)
> : wait_op(&wait_handler::do_complete),
> handler_(static_cast<Handler&&>(h))
> {
> }
>
> static void do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> wait_handler* h(static_cast<wait_handler*>(base));
> ptr p = { boost::asio::detail::addressof(h->handler_), h, h };
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder1<Handler, boost::system::error_code>
> handler(h->handler_, h->ec_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 84 "/usr/include/boost/asio/detail/wait_handler.hpp" 2 3 4
># 31 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 34 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Time_Traits>
>class deadline_timer_service
>{
>public:
>
> typedef typename Time_Traits::time_type time_type;
>
>
> typedef typename Time_Traits::duration_type duration_type;
>
>
>
> struct implementation_type
> : private boost::asio::detail::noncopyable
> {
> time_type expiry;
> bool might_have_pending_waits;
> typename timer_queue<Time_Traits>::per_timer_data timer_data;
> };
>
>
> deadline_timer_service(boost::asio::io_service& io_service)
> : scheduler_(boost::asio::use_service<timer_scheduler>(io_service))
> {
> scheduler_.init_task();
> scheduler_.add_timer_queue(timer_queue_);
> }
>
>
> ~deadline_timer_service()
> {
> scheduler_.remove_timer_queue(timer_queue_);
> }
>
>
> void shutdown_service()
> {
> }
>
>
> void construct(implementation_type& impl)
> {
> impl.expiry = time_type();
> impl.might_have_pending_waits = false;
> }
>
>
> void destroy(implementation_type& impl)
> {
> boost::system::error_code ec;
> cancel(impl, ec);
> }
>
>
> std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
> {
> if (!impl.might_have_pending_waits)
> {
> ec = boost::system::error_code();
> return 0;
> }
>
> (void)0;
>
> std::size_t count = scheduler_.cancel_timer(timer_queue_, impl.timer_data);
> impl.might_have_pending_waits = false;
> ec = boost::system::error_code();
> return count;
> }
>
>
> std::size_t cancel_one(implementation_type& impl,
> boost::system::error_code& ec)
> {
> if (!impl.might_have_pending_waits)
> {
> ec = boost::system::error_code();
> return 0;
> }
>
> (void)0;
>
> std::size_t count = scheduler_.cancel_timer(
> timer_queue_, impl.timer_data, 1);
> if (count == 0)
> impl.might_have_pending_waits = false;
> ec = boost::system::error_code();
> return count;
> }
>
>
> time_type expires_at(const implementation_type& impl) const
> {
> return impl.expiry;
> }
>
>
> std::size_t expires_at(implementation_type& impl,
> const time_type& expiry_time, boost::system::error_code& ec)
> {
> std::size_t count = cancel(impl, ec);
> impl.expiry = expiry_time;
> ec = boost::system::error_code();
> return count;
> }
>
>
> duration_type expires_from_now(const implementation_type& impl) const
> {
> return Time_Traits::subtract(expires_at(impl), Time_Traits::now());
> }
>
>
> std::size_t expires_from_now(implementation_type& impl,
> const duration_type& expiry_time, boost::system::error_code& ec)
> {
> return expires_at(impl,
> Time_Traits::add(Time_Traits::now(), expiry_time), ec);
> }
>
>
> void wait(implementation_type& impl, boost::system::error_code& ec)
> {
> time_type now = Time_Traits::now();
> ec = boost::system::error_code();
> while (Time_Traits::less_than(now, impl.expiry) && !ec)
> {
> this->do_wait(Time_Traits::to_posix_duration(
> Time_Traits::subtract(impl.expiry, now)), ec);
> now = Time_Traits::now();
> }
> }
>
>
> template <typename Handler>
> void async_wait(implementation_type& impl, Handler& handler)
> {
>
> typedef wait_handler<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(handler);
>
> impl.might_have_pending_waits = true;
>
> (void)0;
>
> scheduler_.schedule_timer(timer_queue_, impl.expiry, impl.timer_data, p.p);
> p.v = p.p = 0;
> }
>
>private:
>
>
>
> template <typename Duration>
> void do_wait(const Duration& timeout, boost::system::error_code& ec)
> {
> ::timeval tv;
> tv.tv_sec = timeout.total_seconds();
> tv.tv_usec = timeout.total_microseconds() % 1000000;
> socket_ops::select(0, 0, 0, 0, &tv, ec);
> }
>
>
> timer_queue<Time_Traits> timer_queue_;
>
>
> timer_scheduler& scheduler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 216 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
># 26 "/usr/include/boost/asio/deadline_timer_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/time_traits.hpp" 1 3 4
># 23 "/usr/include/boost/asio/time_traits.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 24 "/usr/include/boost/asio/time_traits.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 1 3 4
># 10 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 3 4
># 1 "/usr/include/boost/date_time/time_clock.hpp" 1 3 4
># 16 "/usr/include/boost/date_time/time_clock.hpp" 3 4
># 1 "/usr/include/boost/date_time/c_time.hpp" 1 3 4
># 17 "/usr/include/boost/date_time/c_time.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/ctime" 1 3 4
># 39 "/usr/include/c++/4.8.2/ctime" 3 4
> 
># 40 "/usr/include/c++/4.8.2/ctime" 3
># 58 "/usr/include/c++/4.8.2/ctime" 3
>namespace std
>{
> using ::clock_t;
> using ::time_t;
> using ::tm;
>
> using ::clock;
> using ::difftime;
> using ::mktime;
> using ::time;
> using ::asctime;
> using ::ctime;
> using ::gmtime;
> using ::localtime;
> using ::strftime;
>}
># 18 "/usr/include/boost/date_time/c_time.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/date_time/compiler_config.hpp" 1 3 4
># 11 "/usr/include/boost/date_time/compiler_config.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstdlib" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstdlib" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstdlib" 3
># 12 "/usr/include/boost/date_time/compiler_config.hpp" 2 3 4
># 31 "/usr/include/boost/date_time/compiler_config.hpp" 3 4
># 1 "/usr/include/boost/date_time/locale_config.hpp" 1 3 4
># 32 "/usr/include/boost/date_time/compiler_config.hpp" 2 3 4
># 54 "/usr/include/boost/date_time/compiler_config.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 55 "/usr/include/boost/date_time/compiler_config.hpp" 2 3 4
># 157 "/usr/include/boost/date_time/compiler_config.hpp" 3 4
># 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
># 158 "/usr/include/boost/date_time/compiler_config.hpp" 2 3 4
># 22 "/usr/include/boost/date_time/c_time.hpp" 2 3 4
># 31 "/usr/include/boost/date_time/c_time.hpp" 3 4
># 1 "/usr/include/sys/time.h" 1 3 4
># 27 "/usr/include/sys/time.h" 3 4
># 1 "/usr/include/bits/time.h" 1 3 4
># 28 "/usr/include/sys/time.h" 2 3 4
># 37 "/usr/include/sys/time.h" 3 4
>extern "C" {
># 55 "/usr/include/sys/time.h" 3 4
>struct timezone
> {
> int tz_minuteswest;
> int tz_dsttime;
> };
>
>typedef struct timezone *__restrict __timezone_ptr_t;
># 71 "/usr/include/sys/time.h" 3 4
>extern int gettimeofday (struct timeval *__restrict __tv,
> __timezone_ptr_t __tz) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int settimeofday (const struct timeval *__tv,
> const struct timezone *__tz)
> throw ();
>
>
>
>
>
>extern int adjtime (const struct timeval *__delta,
> struct timeval *__olddelta) throw ();
>
>
>
>
>enum __itimer_which
> {
>
> ITIMER_REAL = 0,
>
>
> ITIMER_VIRTUAL = 1,
>
>
>
> ITIMER_PROF = 2
>
> };
>
>
>
>struct itimerval
> {
>
> struct timeval it_interval;
>
> struct timeval it_value;
> };
>
>
>
>
>
>
>typedef int __itimer_which_t;
>
>
>
>
>extern int getitimer (__itimer_which_t __which,
> struct itimerval *__value) throw ();
>
>
>
>
>extern int setitimer (__itimer_which_t __which,
> const struct itimerval *__restrict __new,
> struct itimerval *__restrict __old) throw ();
>
>
>
>
>extern int utimes (const char *__file, const struct timeval __tvp[2])
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int lutimes (const char *__file, const struct timeval __tvp[2])
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int futimes (int __fd, const struct timeval __tvp[2]) throw ();
>
>
>
>
>
>
>extern int futimesat (int __fd, const char *__file,
> const struct timeval __tvp[2]) throw ();
># 189 "/usr/include/sys/time.h" 3 4
>}
># 32 "/usr/include/boost/date_time/c_time.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost {
>namespace date_time {
># 52 "/usr/include/boost/date_time/c_time.hpp" 3 4
> struct c_time {
> public:
>
>
> inline
> static std::tm* localtime(const std::time_t* t, std::tm* result)
> {
># 67 "/usr/include/boost/date_time/c_time.hpp" 3 4
> result = localtime_r(t, result);
>
> if (!result)
> boost::throw_exception(std::runtime_error("could not convert calendar time to local time"));
> return result;
> }
>
> inline
> static std::tm* gmtime(const std::time_t* t, std::tm* result)
> {
># 85 "/usr/include/boost/date_time/c_time.hpp" 3 4
> result = gmtime_r(t, result);
>
> if (!result)
> boost::throw_exception(std::runtime_error("could not convert calendar time to UTC time"));
> return result;
> }
># 120 "/usr/include/boost/date_time/c_time.hpp" 3 4
> };
>}}
># 17 "/usr/include/boost/date_time/time_clock.hpp" 2 3 4
># 1 "/usr/include/boost/shared_ptr.hpp" 1 3 4
># 17 "/usr/include/boost/shared_ptr.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 1 3 4
># 27 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
># 1 "/usr/include/boost/config/no_tr1/memory.hpp" 1 3 4
># 28 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
>
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 30 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
># 1 "/usr/include/boost/checked_delete.hpp" 1 3 4
># 24 "/usr/include/boost/checked_delete.hpp" 3 4
>namespace boost
>{
>
>
>
>template<class T> inline void checked_delete(T * x)
>{
>
> typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
> (void) sizeof(type_must_be_complete);
> delete x;
>}
>
>template<class T> inline void checked_array_delete(T * x)
>{
> typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
> (void) sizeof(type_must_be_complete);
> delete [] x;
>}
>
>template<class T> struct checked_deleter
>{
> typedef void result_type;
> typedef T * argument_type;
>
> void operator()(T * x) const
> {
>
> boost::checked_delete(x);
> }
>};
>
>template<class T> struct checked_array_deleter
>{
> typedef void result_type;
> typedef T * argument_type;
>
> void operator()(T * x) const
> {
> boost::checked_array_delete(x);
> }
>};
>
>}
># 31 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
>
># 1 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 1 3 4
># 28 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 1 3 4
># 26 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 3 4
>namespace boost
>{
># 39 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 3 4
>class bad_weak_ptr: public std::exception
>{
>public:
>
> virtual char const * what() const throw()
> {
> return "tr1::bad_weak_ptr";
> }
>};
>
>
>
>
>
>}
># 29 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
># 1 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 1 3 4
># 21 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/detail/sp_has_sync.hpp" 1 3 4
># 22 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2 3 4
># 39 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp" 1 3 4
># 27 "/usr/include/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp" 3 4
># 1 "/usr/include/boost/detail/sp_typeinfo.hpp" 1 3 4
># 111 "/usr/include/boost/detail/sp_typeinfo.hpp" 3 4
>namespace boost
>{
>
>namespace detail
>{
>
>
>
>
>
>
>
>typedef std::type_info sp_typeinfo;
>
>
>
>}
>
>}
># 28 "/usr/include/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp" 2 3 4
>
>namespace boost
>{
>
>namespace detail
>{
>
>inline int atomic_exchange_and_add( int * pw, int dv )
>{
>
>
>
>
> int r;
>
> __asm__ __volatile__
> (
> "lock\n\t"
> "xadd %1, %0":
> "=m"( *pw ), "=r"( r ):
> "m"( *pw ), "1"( dv ):
> "memory", "cc"
> );
>
> return r;
>}
>
>inline void atomic_increment( int * pw )
>{
>
>
> __asm__
> (
> "lock\n\t"
> "incl %0":
> "=m"( *pw ):
> "m"( *pw ):
> "cc"
> );
>}
>
>inline int atomic_conditional_increment( int * pw )
>{
>
>
>
>
> int rv, tmp;
>
> __asm__
> (
> "movl %0, %%eax\n\t"
> "0:\n\t"
> "test %%eax, %%eax\n\t"
> "je 1f\n\t"
> "movl %%eax, %2\n\t"
> "incl %2\n\t"
> "lock\n\t"
> "cmpxchgl %2, %0\n\t"
> "jne 0b\n\t"
> "1:":
> "=m"( *pw ), "=&a"( rv ), "=&r"( tmp ):
> "m"( *pw ):
> "cc"
> );
>
> return rv;
>}
>
>class sp_counted_base
>{
>private:
>
> sp_counted_base( sp_counted_base const & );
> sp_counted_base & operator= ( sp_counted_base const & );
>
> int use_count_;
> int weak_count_;
>
>public:
>
> sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
> {
> }
>
> virtual ~sp_counted_base()
> {
> }
>
>
>
>
> virtual void dispose() = 0;
>
>
>
> virtual void destroy()
> {
> delete this;
> }
>
> virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
> virtual void * get_untyped_deleter() = 0;
>
> void add_ref_copy()
> {
> atomic_increment( &use_count_ );
> }
>
> bool add_ref_lock()
> {
> return atomic_conditional_increment( &use_count_ ) != 0;
> }
>
> void release()
> {
> if( atomic_exchange_and_add( &use_count_, -1 ) == 1 )
> {
> dispose();
> weak_release();
> }
> }
>
> void weak_add_ref()
> {
> atomic_increment( &weak_count_ );
> }
>
> void weak_release()
> {
> if( atomic_exchange_and_add( &weak_count_, -1 ) == 1 )
> {
> destroy();
> }
> }
>
> long use_count() const
> {
> return static_cast<int const volatile &>( use_count_ );
> }
>};
>
>}
>
>}
># 40 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2 3 4
># 30 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
># 1 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 1 3 4
># 38 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 39 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 2 3 4
>
>namespace boost
>{
># 50 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
>namespace detail
>{
>
>template<class X> class sp_counted_impl_p: public sp_counted_base
>{
>private:
>
> X * px_;
>
> sp_counted_impl_p( sp_counted_impl_p const & );
> sp_counted_impl_p & operator= ( sp_counted_impl_p const & );
>
> typedef sp_counted_impl_p<X> this_type;
>
>public:
>
> explicit sp_counted_impl_p( X * px ): px_( px )
> {
>
>
>
> }
>
> virtual void dispose()
> {
>
>
>
> boost::checked_delete( px_ );
> }
>
> virtual void * get_deleter( detail::sp_typeinfo const & )
> {
> return 0;
> }
>
> virtual void * get_untyped_deleter()
> {
> return 0;
> }
># 118 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
>};
># 127 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
>template<class P, class D> class sp_counted_impl_pd: public sp_counted_base
>{
>private:
>
> P ptr;
> D del;
>
> sp_counted_impl_pd( sp_counted_impl_pd const & );
> sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );
>
> typedef sp_counted_impl_pd<P, D> this_type;
>
>public:
>
>
>
> sp_counted_impl_pd( P p, D & d ): ptr( p ), del( d )
> {
> }
>
> sp_counted_impl_pd( P p ): ptr( p ), del()
> {
> }
>
> virtual void dispose()
> {
> del( ptr );
> }
>
> virtual void * get_deleter( detail::sp_typeinfo const & ti )
> {
> return ti == typeid(D)? &reinterpret_cast<char&>( del ): 0;
> }
>
> virtual void * get_untyped_deleter()
> {
> return &reinterpret_cast<char&>( del );
> }
># 193 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
>};
>
>template<class P, class D, class A> class sp_counted_impl_pda: public sp_counted_base
>{
>private:
>
> P p_;
> D d_;
> A a_;
>
> sp_counted_impl_pda( sp_counted_impl_pda const & );
> sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );
>
> typedef sp_counted_impl_pda<P, D, A> this_type;
>
>public:
>
>
>
> sp_counted_impl_pda( P p, D & d, A a ): p_( p ), d_( d ), a_( a )
> {
> }
>
> sp_counted_impl_pda( P p, A a ): p_( p ), d_(), a_( a )
> {
> }
>
> virtual void dispose()
> {
> d_( p_ );
> }
>
> virtual void destroy()
> {
> typedef typename A::template rebind< this_type >::other A2;
>
> A2 a2( a_ );
>
> this->~this_type();
> a2.deallocate( this, 1 );
> }
>
> virtual void * get_deleter( detail::sp_typeinfo const & ti )
> {
> return ti == typeid(D)? &reinterpret_cast<char&>( d_ ): 0;
> }
>
> virtual void * get_untyped_deleter()
> {
> return &reinterpret_cast<char&>( d_ );
> }
>};
>
>
>
>
>
>}
>
>}
># 31 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
># 47 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
>namespace boost
>{
>
>namespace detail
>{
># 60 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
>struct sp_nothrow_tag {};
>
>template< class D > struct sp_inplace_tag
>{
>};
>
>
>
>template< class T > class sp_reference_wrapper
>{
>public:
>
> explicit sp_reference_wrapper( T & t): t_( boost::addressof( t ) )
> {
> }
>
> template< class Y > void operator()( Y * p ) const
> {
> (*t_)( p );
> }
>
>private:
>
> T * t_;
>};
>
>template< class D > struct sp_convert_reference
>{
> typedef D type;
>};
>
>template< class D > struct sp_convert_reference< D& >
>{
> typedef sp_reference_wrapper< D > type;
>};
>
>
>
>class weak_count;
>
>class shared_count
>{
>private:
>
> sp_counted_base * pi_;
>
>
>
>
>
> friend class weak_count;
>
>public:
>
> shared_count(): pi_(0)
>
>
>
> {
> }
>
> template<class Y> explicit shared_count( Y * p ): pi_( 0 )
>
>
>
> {
>
>
> try
> {
> pi_ = new sp_counted_impl_p<Y>( p );
> }
> catch(...)
> {
> boost::checked_delete( p );
> throw;
> }
># 149 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
> }
>
>
>
>
> template<class P, class D> shared_count( P p, D d ): pi_(0)
>
>
>
>
> {
>
>
>
>
>
> try
> {
> pi_ = new sp_counted_impl_pd<P, D>(p, d);
> }
> catch(...)
> {
> d(p);
> throw;
> }
># 186 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
> }
>
>
>
> template< class P, class D > shared_count( P p, sp_inplace_tag<D> ): pi_( 0 )
>
>
>
> {
>
>
> try
> {
> pi_ = new sp_counted_impl_pd< P, D >( p );
> }
> catch( ... )
> {
> D::operator_fn( p );
> throw;
> }
># 218 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
> }
>
>
>
> template<class P, class D, class A> shared_count( P p, D d, A a ): pi_( 0 )
>
>
>
> {
> typedef sp_counted_impl_pda<P, D, A> impl_type;
> typedef typename A::template rebind< impl_type >::other A2;
>
> A2 a2( a );
>
>
>
> try
> {
> pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
> new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
> }
> catch(...)
> {
> d( p );
>
> if( pi_ != 0 )
> {
> a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
> }
>
> throw;
> }
># 266 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
> }
>
>
>
> template< class P, class D, class A > shared_count( P p, sp_inplace_tag< D >, A a ): pi_( 0 )
>
>
>
> {
> typedef sp_counted_impl_pda< P, D, A > impl_type;
> typedef typename A::template rebind< impl_type >::other A2;
>
> A2 a2( a );
>
>
>
> try
> {
> pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
> new( static_cast< void* >( pi_ ) ) impl_type( p, a );
> }
> catch(...)
> {
> D::operator_fn( p );
>
> if( pi_ != 0 )
> {
> a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
> }
>
> throw;
> }
># 314 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
> }
>
>
>
>
>
>
>
> template<class Y>
> explicit shared_count( std::auto_ptr<Y> & r ): pi_( new sp_counted_impl_p<Y>( r.get() ) )
>
>
>
> {
># 337 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
> r.release();
> }
>
>
>
>
>
> template<class Y, class D>
> explicit shared_count( std::unique_ptr<Y, D> & r ): pi_( 0 )
>
>
>
> {
> typedef typename sp_convert_reference<D>::type D2;
>
> D2 d2( r.get_deleter() );
> pi_ = new sp_counted_impl_pd< typename std::unique_ptr<Y, D>::pointer, D2 >( r.get(), d2 );
># 364 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
> r.release();
> }
>
>
>
> ~shared_count()
> {
> if( pi_ != 0 ) pi_->release();
>
>
>
> }
>
> shared_count(shared_count const & r): pi_(r.pi_)
>
>
>
> {
> if( pi_ != 0 ) pi_->add_ref_copy();
> }
>
>
>
> shared_count(shared_count && r): pi_(r.pi_)
>
>
>
> {
> r.pi_ = 0;
> }
>
>
>
> explicit shared_count(weak_count const & r);
> shared_count( weak_count const & r, sp_nothrow_tag );
>
> shared_count & operator= (shared_count const & r)
> {
> sp_counted_base * tmp = r.pi_;
>
> if( tmp != pi_ )
> {
> if( tmp != 0 ) tmp->add_ref_copy();
> if( pi_ != 0 ) pi_->release();
> pi_ = tmp;
> }
>
> return *this;
> }
>
> void swap(shared_count & r)
> {
> sp_counted_base * tmp = r.pi_;
> r.pi_ = pi_;
> pi_ = tmp;
> }
>
> long use_count() const
> {
> return pi_ != 0? pi_->use_count(): 0;
> }
>
> bool unique() const
> {
> return use_count() == 1;
> }
>
> bool empty() const
> {
> return pi_ == 0;
> }
>
> friend inline bool operator==(shared_count const & a, shared_count const & b)
> {
> return a.pi_ == b.pi_;
> }
>
> friend inline bool operator<(shared_count const & a, shared_count const & b)
> {
> return std::less<sp_counted_base *>()( a.pi_, b.pi_ );
> }
>
> void * get_deleter( sp_typeinfo const & ti ) const
> {
> return pi_? pi_->get_deleter( ti ): 0;
> }
>
> void * get_untyped_deleter() const
> {
> return pi_? pi_->get_untyped_deleter(): 0;
> }
>};
>
>
>class weak_count
>{
>private:
>
> sp_counted_base * pi_;
>
>
>
>
>
> friend class shared_count;
>
>public:
>
> weak_count(): pi_(0)
>
>
>
> {
> }
>
> weak_count(shared_count const & r): pi_(r.pi_)
>
>
>
> {
> if(pi_ != 0) pi_->weak_add_ref();
> }
>
> weak_count(weak_count const & r): pi_(r.pi_)
>
>
>
> {
> if(pi_ != 0) pi_->weak_add_ref();
> }
>
>
>
>
>
> weak_count(weak_count && r): pi_(r.pi_)
>
>
>
> {
> r.pi_ = 0;
> }
>
>
>
> ~weak_count()
> {
> if(pi_ != 0) pi_->weak_release();
>
>
>
> }
>
> weak_count & operator= (shared_count const & r)
> {
> sp_counted_base * tmp = r.pi_;
>
> if( tmp != pi_ )
> {
> if(tmp != 0) tmp->weak_add_ref();
> if(pi_ != 0) pi_->weak_release();
> pi_ = tmp;
> }
>
> return *this;
> }
>
> weak_count & operator= (weak_count const & r)
> {
> sp_counted_base * tmp = r.pi_;
>
> if( tmp != pi_ )
> {
> if(tmp != 0) tmp->weak_add_ref();
> if(pi_ != 0) pi_->weak_release();
> pi_ = tmp;
> }
>
> return *this;
> }
>
> void swap(weak_count & r)
> {
> sp_counted_base * tmp = r.pi_;
> r.pi_ = pi_;
> pi_ = tmp;
> }
>
> long use_count() const
> {
> return pi_ != 0? pi_->use_count(): 0;
> }
>
> bool empty() const
> {
> return pi_ == 0;
> }
>
> friend inline bool operator==(weak_count const & a, weak_count const & b)
> {
> return a.pi_ == b.pi_;
> }
>
> friend inline bool operator<(weak_count const & a, weak_count const & b)
> {
> return std::less<sp_counted_base *>()(a.pi_, b.pi_);
> }
>};
>
>inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
>
>
>
>{
> if( pi_ == 0 || !pi_->add_ref_lock() )
> {
> boost::throw_exception( boost::bad_weak_ptr() );
> }
>}
>
>inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_( r.pi_ )
>
>
>
>{
> if( pi_ != 0 && !pi_->add_ref_lock() )
> {
> pi_ = 0;
> }
>}
>
>}
>
>}
># 33 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
>
># 1 "/usr/include/boost/smart_ptr/detail/sp_convertible.hpp" 1 3 4
># 34 "/usr/include/boost/smart_ptr/detail/sp_convertible.hpp" 3 4
>namespace boost
>{
>
>namespace detail
>{
>
>template< class Y, class T > struct sp_convertible
>{
> typedef char (&yes) [1];
> typedef char (&no) [2];
>
> static yes f( T* );
> static no f( ... );
>
> enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
>};
>
>template< class Y, class T > struct sp_convertible< Y, T[] >
>{
> enum _vt { value = false };
>};
>
>template< class Y, class T > struct sp_convertible< Y[], T[] >
>{
> enum _vt { value = sp_convertible< Y[1], T[1] >::value };
>};
>
>template< class Y, std::size_t N, class T > struct sp_convertible< Y[N], T[] >
>{
> enum _vt { value = sp_convertible< Y[1], T[1] >::value };
>};
>
>struct sp_empty
>{
>};
>
>template< bool > struct sp_enable_if_convertible_impl;
>
>template<> struct sp_enable_if_convertible_impl<true>
>{
> typedef sp_empty type;
>};
>
>template<> struct sp_enable_if_convertible_impl<false>
>{
>};
>
>template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
>{
>};
>
>}
>
>}
># 35 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
># 1 "/usr/include/boost/smart_ptr/detail/sp_nullptr_t.hpp" 1 3 4
># 19 "/usr/include/boost/smart_ptr/detail/sp_nullptr_t.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/smart_ptr/detail/sp_nullptr_t.hpp" 2 3 4
>
>
>
>namespace boost
>{
>
>namespace detail
>{
>
>
>
>
>
>
>
> typedef std::nullptr_t sp_nullptr_t;
>
>
>
>}
>
>}
># 36 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 1 3 4
># 25 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/detail/spinlock.hpp" 1 3 4
># 41 "/usr/include/boost/smart_ptr/detail/spinlock.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/detail/spinlock_sync.hpp" 1 3 4
># 18 "/usr/include/boost/smart_ptr/detail/spinlock_sync.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 1 3 4
># 91 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 3 4
>namespace boost
>{
>
>namespace detail
>{
>
>inline void yield( unsigned k )
>{
> if( k < 4 )
> {
> }
>
> else if( k < 16 )
> {
> __asm__ __volatile__( "rep; nop" : : : "memory" );
> }
>
> else if( k < 32 || k & 1 )
> {
> sched_yield();
> }
> else
> {
>
> struct timespec rqtp = { 0, 0 };
>
>
>
>
> rqtp.tv_sec = 0;
> rqtp.tv_nsec = 1000;
>
> nanosleep( &rqtp, 0 );
> }
>}
>
>}
>
>}
># 19 "/usr/include/boost/smart_ptr/detail/spinlock_sync.hpp" 2 3 4
>
>
>
>
>
>namespace boost
>{
>
>namespace detail
>{
>
>class spinlock
>{
>public:
>
> int v_;
>
>public:
>
> bool try_lock()
> {
> int r = __sync_lock_test_and_set( &v_, 1 );
> return r == 0;
> }
>
> void lock()
> {
> for( unsigned k = 0; !try_lock(); ++k )
> {
> boost::detail::yield( k );
> }
> }
>
> void unlock()
> {
> __sync_lock_release( &v_ );
> }
>
>public:
>
> class scoped_lock
> {
> private:
>
> spinlock & sp_;
>
> scoped_lock( scoped_lock const & );
> scoped_lock & operator=( scoped_lock const & );
>
> public:
>
> explicit scoped_lock( spinlock & sp ): sp_( sp )
> {
> sp.lock();
> }
>
> ~scoped_lock()
> {
> sp_.unlock();
> }
> };
>};
>
>}
>}
># 42 "/usr/include/boost/smart_ptr/detail/spinlock.hpp" 2 3 4
># 26 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 2 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 27 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 2 3 4
>
>namespace boost
>{
>
>namespace detail
>{
>
>template< int I > class spinlock_pool
>{
>private:
>
> static spinlock pool_[ 41 ];
>
>public:
>
> static spinlock & spinlock_for( void const * pv )
> {
>
>
>
> std::size_t i = reinterpret_cast< std::size_t >( pv ) % 41;
>
> return pool_[ i ];
> }
>
> class scoped_lock
> {
> private:
>
> spinlock & sp_;
>
> scoped_lock( scoped_lock const & );
> scoped_lock & operator=( scoped_lock const & );
>
> public:
>
> explicit scoped_lock( void const * pv ): sp_( spinlock_for( pv ) )
> {
> sp_.lock();
> }
>
> ~scoped_lock()
> {
> sp_.unlock();
> }
> };
>};
>
>template< int I > spinlock spinlock_pool::pool_[ 41 ] =
>{
> {0}, {0}, {0}, {0}, {0},
> {0}, {0}, {0}, {0}, {0},
> {0}, {0}, {0}, {0}, {0},
> {0}, {0}, {0}, {0}, {0},
> {0}, {0}, {0}, {0}, {0},
> {0}, {0}, {0}, {0}, {0},
> {0}, {0}, {0}, {0}, {0},
> {0}, {0}, {0}, {0}, {0},
> {0}
>};
>
>}
>}
># 39 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
># 1 "/usr/include/boost/memory_order.hpp" 1 3 4
># 21 "/usr/include/boost/memory_order.hpp" 3 4
>namespace boost
>{
># 41 "/usr/include/boost/memory_order.hpp" 3 4
>enum memory_order
>{
> memory_order_relaxed = 0,
> memory_order_acquire = 1,
> memory_order_release = 2,
> memory_order_acq_rel = 3,
> memory_order_seq_cst = 7,
> memory_order_consume = 8
>};
>
>}
># 40 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 46 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
># 55 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
>namespace boost
>{
>
>template<class T> class shared_ptr;
>template<class T> class weak_ptr;
>template<class T> class enable_shared_from_this;
>class enable_shared_from_raw;
>
>namespace detail
>{
>
>
>
>template< class T > struct sp_element
>{
> typedef T type;
>};
>
>
>
>template< class T > struct sp_element< T[] >
>{
> typedef T type;
>};
>
>
>
>template< class T, std::size_t N > struct sp_element< T[N] >
>{
> typedef T type;
>};
>
>
>
>
>
>
>
>template< class T > struct sp_dereference
>{
> typedef T & type;
>};
>
>template<> struct sp_dereference< void >
>{
> typedef void type;
>};
>
>
>
>template<> struct sp_dereference< void const >
>{
> typedef void type;
>};
>
>template<> struct sp_dereference< void volatile >
>{
> typedef void type;
>};
>
>template<> struct sp_dereference< void const volatile >
>{
> typedef void type;
>};
>
>
>
>
>
>template< class T > struct sp_dereference< T[] >
>{
> typedef void type;
>};
>
>
>
>template< class T, std::size_t N > struct sp_dereference< T[N] >
>{
> typedef void type;
>};
>
>
>
>
>
>
>
>template< class T > struct sp_member_access
>{
> typedef T * type;
>};
>
>
>
>template< class T > struct sp_member_access< T[] >
>{
> typedef void type;
>};
>
>
>
>template< class T, std::size_t N > struct sp_member_access< T[N] >
>{
> typedef void type;
>};
>
>
>
>
>
>
>
>template< class T > struct sp_array_access
>{
> typedef void type;
>};
>
>
>
>template< class T > struct sp_array_access< T[] >
>{
> typedef T & type;
>};
>
>
>
>template< class T, std::size_t N > struct sp_array_access< T[N] >
>{
> typedef T & type;
>};
>
>
>
>
>
>
>
>template< class T > struct sp_extent
>{
> enum _vt { value = 0 };
>};
>
>
>
>template< class T, std::size_t N > struct sp_extent< T[N] >
>{
> enum _vt { value = N };
>};
>
>
>
>
>
>template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
>{
> if( pe != 0 )
> {
> pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
> }
>}
>
>template< class X, class Y > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_raw const * pe );
># 233 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
>inline void sp_enable_shared_from_this( ... )
>{
>}
>
>
>
>
>
>
>
>template< class T, class R > struct sp_enable_if_auto_ptr
>{
>};
>
>template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
>{
> typedef R type;
>};
>
>
>
>
>
>template< class Y, class T > inline void sp_assert_convertible()
>{
>
>
>
> typedef char tmp[ sp_convertible< Y, T >::value? 1: -1 ];
> (void)sizeof( tmp );
>
>
>
>
>
>
>
>}
>
>
>
>template< class T, class Y > inline void sp_pointer_construct( boost::shared_ptr< T > * ppx, Y * p, boost::detail::shared_count & pn )
>{
> boost::detail::shared_count( p ).swap( pn );
> boost::detail::sp_enable_shared_from_this( ppx, p, p );
>}
>
>
>
>template< class T, class Y > inline void sp_pointer_construct( boost::shared_ptr< T[] > * , Y * p, boost::detail::shared_count & pn )
>{
> sp_assert_convertible< Y[], T[] >();
> boost::detail::shared_count( p, boost::checked_array_deleter< T >() ).swap( pn );
>}
>
>template< class T, std::size_t N, class Y > inline void sp_pointer_construct( boost::shared_ptr< T[N] > * , Y * p, boost::detail::shared_count & pn )
>{
> sp_assert_convertible< Y[N], T[N] >();
> boost::detail::shared_count( p, boost::checked_array_deleter< T >() ).swap( pn );
>}
>
>
>
>
>
>template< class T, class Y > inline void sp_deleter_construct( boost::shared_ptr< T > * ppx, Y * p )
>{
> boost::detail::sp_enable_shared_from_this( ppx, p, p );
>}
>
>
>
>template< class T, class Y > inline void sp_deleter_construct( boost::shared_ptr< T[] > * , Y * )
>{
> sp_assert_convertible< Y[], T[] >();
>}
>
>template< class T, std::size_t N, class Y > inline void sp_deleter_construct( boost::shared_ptr< T[N] > * , Y * )
>{
> sp_assert_convertible< Y[N], T[N] >();
>}
>
>
>
>}
># 328 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
>template<class T> class shared_ptr
>{
>private:
>
>
> typedef shared_ptr<T> this_type;
>
>public:
>
> typedef typename boost::detail::sp_element< T >::type element_type;
>
> shared_ptr() noexcept : px( 0 ), pn()
> {
> }
>
>
>
> shared_ptr( boost::detail::sp_nullptr_t ) noexcept : px( 0 ), pn()
> {
> }
>
>
>
> template<class Y>
> explicit shared_ptr( Y * p ): px( p ), pn()
> {
> boost::detail::sp_pointer_construct( this, p, pn );
> }
>
>
>
>
>
>
>
> template<class Y, class D> shared_ptr( Y * p, D d ): px( p ), pn( p, d )
> {
> boost::detail::sp_deleter_construct( this, p );
> }
>
>
>
> template<class D> shared_ptr( boost::detail::sp_nullptr_t p, D d ): px( p ), pn( p, d )
> {
> }
>
>
>
>
>
> template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
> {
> boost::detail::sp_deleter_construct( this, p );
> }
>
>
>
> template<class D, class A> shared_ptr( boost::detail::sp_nullptr_t p, D d, A a ): px( p ), pn( p, d, a )
> {
> }
># 397 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
> shared_ptr( shared_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
> {
> }
>
>
>
> template<class Y>
> explicit shared_ptr( weak_ptr<Y> const & r ): pn( r.pn )
> {
> boost::detail::sp_assert_convertible< Y, T >();
>
>
> px = r.px;
> }
>
> template<class Y>
> shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag )
> noexcept : px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
> {
> if( !pn.empty() )
> {
> px = r.px;
> }
> }
>
> template<class Y>
>
>
> shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
>
>
>
>
>
>
> noexcept : px( r.px ), pn( r.pn )
> {
> boost::detail::sp_assert_convertible< Y, T >();
> }
>
>
> template< class Y >
> shared_ptr( shared_ptr<Y> const & r, element_type * p ) noexcept : px( p ), pn( r.pn )
> {
> }
>
>
>
> template<class Y>
> explicit shared_ptr( std::auto_ptr<Y> & r ): px(r.get()), pn()
> {
> boost::detail::sp_assert_convertible< Y, T >();
>
> Y * tmp = r.get();
> pn = boost::detail::shared_count( r );
>
> boost::detail::sp_deleter_construct( this, tmp );
> }
>
>
>
> template<class Y>
> shared_ptr( std::auto_ptr<Y> && r ): px(r.get()), pn()
> {
> boost::detail::sp_assert_convertible< Y, T >();
>
> Y * tmp = r.get();
> pn = boost::detail::shared_count( r );
>
> boost::detail::sp_deleter_construct( this, tmp );
> }
># 490 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
> template< class Y, class D >
> shared_ptr( std::unique_ptr< Y, D > && r ): px( r.get() ), pn()
> {
> boost::detail::sp_assert_convertible< Y, T >();
>
> typename std::unique_ptr< Y, D >::pointer tmp = r.get();
> pn = boost::detail::shared_count( r );
>
> boost::detail::sp_deleter_construct( this, tmp );
> }
>
>
>
>
>
> shared_ptr & operator=( shared_ptr const & r ) noexcept
> {
> this_type(r).swap(*this);
> return *this;
> }
>
>
>
> template<class Y>
> shared_ptr & operator=(shared_ptr<Y> const & r) noexcept
> {
> this_type(r).swap(*this);
> return *this;
> }
>
>
>
>
>
> template<class Y>
> shared_ptr & operator=( std::auto_ptr<Y> & r )
> {
> this_type( r ).swap( *this );
> return *this;
> }
>
>
>
> template<class Y>
> shared_ptr & operator=( std::auto_ptr<Y> && r )
> {
> this_type( static_cast< std::auto_ptr<Y> && >( r ) ).swap( *this );
> return *this;
> }
># 555 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
> template<class Y, class D>
> shared_ptr & operator=( std::unique_ptr<Y, D> && r )
> {
> this_type( static_cast< std::unique_ptr<Y, D> && >( r ) ).swap(*this);
> return *this;
> }
>
>
>
>
>
>
>
> shared_ptr( shared_ptr && r ) noexcept : px( r.px ), pn()
> {
> pn.swap( r.pn );
> r.px = 0;
> }
>
> template<class Y>
>
>
> shared_ptr( shared_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
>
>
>
>
>
>
> noexcept : px( r.px ), pn()
> {
> boost::detail::sp_assert_convertible< Y, T >();
>
> pn.swap( r.pn );
> r.px = 0;
> }
>
> shared_ptr & operator=( shared_ptr && r ) noexcept
> {
> this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
> return *this;
> }
>
> template<class Y>
> shared_ptr & operator=( shared_ptr<Y> && r ) noexcept
> {
> this_type( static_cast< shared_ptr<Y> && >( r ) ).swap( *this );
> return *this;
> }
>
>
>
>
>
> shared_ptr & operator=( boost::detail::sp_nullptr_t ) noexcept
> {
> this_type().swap(*this);
> return *this;
> }
>
>
>
> void reset() noexcept
> {
> this_type().swap(*this);
> }
>
> template<class Y> void reset( Y * p )
> {
> ((void)0);
> this_type( p ).swap( *this );
> }
>
> template<class Y, class D> void reset( Y * p, D d )
> {
> this_type( p, d ).swap( *this );
> }
>
> template<class Y, class D, class A> void reset( Y * p, D d, A a )
> {
> this_type( p, d, a ).swap( *this );
> }
>
> template<class Y> void reset( shared_ptr<Y> const & r, element_type * p )
> {
> this_type( r, p ).swap( *this );
> }
>
>
> typename boost::detail::sp_dereference< T >::type operator* () const
> {
> ((void)0);
> return *px;
> }
>
>
> typename boost::detail::sp_member_access< T >::type operator-> () const
> {
> ((void)0);
> return px;
> }
>
>
> typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const
> {
> ((void)0);
> ((void)0);
>
> return px[ i ];
> }
>
> element_type * get() const noexcept
> {
> return px;
> }
>
>
># 1 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 1 3 4
># 11 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
> explicit operator bool () const noexcept
> {
> return px != 0;
> }
># 60 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
> bool operator! () const noexcept
> {
> return px == 0;
> }
># 673 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
>
> bool unique() const noexcept
> {
> return pn.unique();
> }
>
> long use_count() const noexcept
> {
> return pn.use_count();
> }
>
> void swap( shared_ptr & other ) noexcept
> {
> std::swap(px, other.px);
> pn.swap(other.pn);
> }
>
> template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const noexcept
> {
> return pn < rhs.pn;
> }
>
> template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const noexcept
> {
> return pn < rhs.pn;
> }
>
> void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const noexcept
> {
> return pn.get_deleter( ti );
> }
>
> void * _internal_get_untyped_deleter() const noexcept
> {
> return pn.get_untyped_deleter();
> }
>
> bool _internal_equiv( shared_ptr const & r ) const noexcept
> {
> return px == r.px && pn == r.pn;
> }
>
>
>
>
>
>
>private:
>
> template<class Y> friend class shared_ptr;
> template<class Y> friend class weak_ptr;
>
>
>
>
> element_type * px;
> boost::detail::shared_count pn;
>
>};
>
>template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr const & b) noexcept
>{
> return a.get() == b.get();
>}
>
>template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr const & b) noexcept
>{
> return a.get() != b.get();
>}
># 756 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
>template<class T> inline bool operator==( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
>{
> return p.get() == 0;
>}
>
>template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
>{
> return p.get() == 0;
>}
>
>template<class T> inline bool operator!=( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
>{
> return p.get() != 0;
>}
>
>template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
>{
> return p.get() != 0;
>}
>
>
>
>template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr const & b) noexcept
>{
> return a.owner_before( b );
>}
>
>template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b) noexcept
>{
> a.swap(b);
>}
>
>template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr const & r ) noexcept
>{
> (void) static_cast< T* >( static_cast< U* >( 0 ) );
>
> typedef typename shared_ptr<T>::element_type E;
>
> E * p = static_cast< E* >( r.get() );
> return shared_ptr<T>( r, p );
>}
>
>template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr const & r ) noexcept
>{
> (void) const_cast< T* >( static_cast< U* >( 0 ) );
>
> typedef typename shared_ptr<T>::element_type E;
>
> E * p = const_cast< E* >( r.get() );
> return shared_ptr<T>( r, p );
>}
>
>template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr const & r ) noexcept
>{
> (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
>
> typedef typename shared_ptr<T>::element_type E;
>
> E * p = dynamic_cast< E* >( r.get() );
> return p? shared_ptr<T>( r, p ): shared_ptr<T>();
>}
>
>template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr const & r ) noexcept
>{
> (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
>
> typedef typename shared_ptr<T>::element_type E;
>
> E * p = reinterpret_cast< E* >( r.get() );
> return shared_ptr<T>( r, p );
>}
>
>
>
>template<class T> inline typename shared_ptr<T>::element_type * get_pointer(shared_ptr<T> const & p) noexcept
>{
> return p.get();
>}
># 857 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
>template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
>
>{
> os << p.get();
> return os;
>}
># 872 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
>namespace detail
>{
># 890 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
>template<class D, class T> D * basic_get_deleter( shared_ptr<T> const & p ) noexcept
>{
> return static_cast<D *>( p._internal_get_deleter(typeid(D)) );
>}
>
>
>
>class esft2_deleter_wrapper
>{
>private:
>
> shared_ptr<void> deleter_;
>
>public:
>
> esft2_deleter_wrapper()
> {
> }
>
> template< class T > void set_deleter( shared_ptr<T> const & deleter )
> {
> deleter_ = deleter;
> }
>
> template<typename D> D* get_deleter() const noexcept
> {
> return boost::detail::basic_get_deleter<D>( deleter_ );
> }
>
> template< class T> void operator()( T* )
> {
> ((void)0);
> deleter_.reset();
> }
>};
>
>}
>
>template<class D, class T> D * get_deleter( shared_ptr<T> const & p ) noexcept
>{
> D *del = boost::detail::basic_get_deleter<D>(p);
>
> if(del == 0)
> {
> boost::detail::esft2_deleter_wrapper *del_wrapper = boost::detail::basic_get_deleter<boost::detail::esft2_deleter_wrapper>(p);
>
>
> if(del_wrapper) del = del_wrapper->::boost::detail::esft2_deleter_wrapper::get_deleter<D>();
> }
>
> return del;
>}
>
>
>
>
>
>template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * ) noexcept
>{
> return false;
>}
>
>template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
>{
> boost::detail::spinlock_pool<2>::scoped_lock lock( p );
> return *p;
>}
>
>template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, memory_order )
>{
> return atomic_load( p );
>}
>
>template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
>{
> boost::detail::spinlock_pool<2>::scoped_lock lock( p );
> p->swap( r );
>}
>
>template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
>{
> atomic_store( p, r );
>}
>
>template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
>{
> boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
>
> sp.lock();
> p->swap( r );
> sp.unlock();
>
> return r;
>}
>
>template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
>{
> return atomic_exchange( p, r );
>}
>
>template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
>{
> boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
>
> sp.lock();
>
> if( p->_internal_equiv( *v ) )
> {
> p->swap( w );
>
> sp.unlock();
>
> return true;
> }
> else
> {
> shared_ptr<T> tmp( *p );
>
> sp.unlock();
>
> tmp.swap( *v );
> return false;
> }
>}
>
>template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, memory_order , memory_order )
>{
> return atomic_compare_exchange( p, v, w );
>}
>
>
>
>
>
>template< class T > struct hash;
>
>template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) noexcept
>{
> return boost::hash< T* >()( p.get() );
>}
>
>}
># 18 "/usr/include/boost/shared_ptr.hpp" 2 3 4
># 18 "/usr/include/boost/date_time/time_clock.hpp" 2 3 4
>
>namespace boost {
>namespace date_time {
>
>
>
>
>
> template<class time_type>
> class second_clock
> {
> public:
> typedef typename time_type::date_type date_type;
> typedef typename time_type::time_duration_type time_duration_type;
>
> static time_type local_time()
> {
> ::std::time_t t;
> ::std::time(&t);
> ::std::tm curr, *curr_ptr;
>
> curr_ptr = c_time::localtime(&t, &curr);
> return create_time(curr_ptr);
> }
>
>
>
> static time_type universal_time()
> {
>
> ::std::time_t t;
> ::std::time(&t);
> ::std::tm curr, *curr_ptr;
>
> curr_ptr = c_time::gmtime(&t, &curr);
> return create_time(curr_ptr);
> }
>
> template<class time_zone_type>
> static time_type local_time(boost::shared_ptr<time_zone_type> tz_ptr)
> {
> typedef typename time_type::utc_time_type utc_time_type;
> utc_time_type utc_time = second_clock<utc_time_type>::universal_time();
> return time_type(utc_time, tz_ptr);
> }
>
>
> private:
> static time_type create_time(::std::tm* current)
> {
> date_type d(static_cast<unsigned short>(current->tm_year + 1900),
> static_cast<unsigned short>(current->tm_mon + 1),
> static_cast<unsigned short>(current->tm_mday));
> time_duration_type td(current->tm_hour,
> current->tm_min,
> current->tm_sec);
> return time_type(d,td);
> }
>
> };
>
>
>} }
># 11 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/microsec_time_clock.hpp" 1 3 4
># 17 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 18 "/usr/include/boost/date_time/microsec_time_clock.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/date_time/filetime_functions.hpp" 1 3 4
># 24 "/usr/include/boost/date_time/microsec_time_clock.hpp" 2 3 4
>
>
>
>namespace boost {
>namespace date_time {
># 38 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
> template<class time_type>
> class microsec_clock
> {
> private:
>
> typedef std::tm* (*time_converter)(const std::time_t*, std::tm*);
>
> public:
> typedef typename time_type::date_type date_type;
> typedef typename time_type::time_duration_type time_duration_type;
> typedef typename time_duration_type::rep_type resolution_traits_type;
>
>
>
> template<class time_zone_type>
> static time_type local_time(shared_ptr<time_zone_type> tz_ptr)
> {
> typedef typename time_type::utc_time_type utc_time_type;
> typedef second_clock<utc_time_type> second_clock;
>
>
> utc_time_type utc_time = second_clock::universal_time();
> time_duration_type utc_offset = second_clock::local_time() - utc_time;
>
>
> utc_time = microsec_clock<utc_time_type>::local_time() - utc_offset;
> return time_type(utc_time, tz_ptr);
> }
>
>
> static time_type local_time()
> {
> return create_time(&c_time::localtime);
> }
>
>
> static time_type universal_time()
> {
> return create_time(&c_time::gmtime);
> }
>
> private:
> static time_type create_time(time_converter converter)
> {
>
> timeval tv;
> gettimeofday(&tv, 0);
> std::time_t t = tv.tv_sec;
> boost::uint32_t sub_sec = tv.tv_usec;
># 99 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
> std::tm curr;
> std::tm* curr_ptr = converter(&t, &curr);
> date_type d(static_cast< typename date_type::year_type::value_type >(curr_ptr->tm_year + 1900),
> static_cast< typename date_type::month_type::value_type >(curr_ptr->tm_mon + 1),
> static_cast< typename date_type::day_type::value_type >(curr_ptr->tm_mday));
>
>
>
>
>
> int adjust = static_cast< int >(resolution_traits_type::res_adjust() / 1000000);
>
> time_duration_type td(static_cast< typename time_duration_type::hour_type >(curr_ptr->tm_hour),
> static_cast< typename time_duration_type::min_type >(curr_ptr->tm_min),
> static_cast< typename time_duration_type::sec_type >(curr_ptr->tm_sec),
> sub_sec * adjust);
>
> return time_type(d,td);
> }
> };
>
>
>} }
># 12 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/posix_time/ptime.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/posix_time/ptime.hpp" 3 4
># 1 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 3 4
># 1 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstdlib" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstdlib" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstdlib" 3
># 13 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
>
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 15 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
># 1 "/usr/include/boost/config/no_tr1/cmath.hpp" 1 3 4
># 21 "/usr/include/boost/config/no_tr1/cmath.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cmath" 1 3 4
># 39 "/usr/include/c++/4.8.2/cmath" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cmath" 3
># 22 "/usr/include/boost/config/no_tr1/cmath.hpp" 2 3 4
># 16 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/time_duration.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/time_duration.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/date_time/time_defs.hpp" 1 3 4
># 19 "/usr/include/boost/date_time/time_defs.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
> enum time_resolutions {
> sec,
> tenth,
> hundreth,
> hundredth = hundreth,
> milli,
> ten_thousandth,
> micro,
> nano,
> NumResolutions
> };
>
>
> enum dst_flags {not_dst, is_dst, calculate};
>
>
>} }
># 16 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/special_defs.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/special_defs.hpp" 3 4
>namespace boost {
>namespace date_time {
>
> enum special_values {not_a_date_time,
> neg_infin, pos_infin,
> min_date_time, max_date_time,
> not_special, NumSpecialValues};
>
>
>} }
># 17 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4
>
>
>namespace boost {
>namespace date_time {
># 33 "/usr/include/boost/date_time/time_duration.hpp" 3 4
> template<class T, typename rep_type>
> class time_duration : private
> boost::less_than_comparable<T
> , boost::equality_comparable<T
> > >
>
>
>
>
>
> {
> public:
> typedef T duration_type;
> typedef rep_type traits_type;
> typedef typename rep_type::day_type day_type;
> typedef typename rep_type::hour_type hour_type;
> typedef typename rep_type::min_type min_type;
> typedef typename rep_type::sec_type sec_type;
> typedef typename rep_type::fractional_seconds_type fractional_seconds_type;
> typedef typename rep_type::tick_type tick_type;
> typedef typename rep_type::impl_type impl_type;
>
> time_duration() : ticks_(0) {}
> time_duration(hour_type hours_in,
> min_type minutes_in,
> sec_type seconds_in=0,
> fractional_seconds_type frac_sec_in = 0) :
> ticks_(rep_type::to_tick_count(hours_in,minutes_in,seconds_in,frac_sec_in))
> {}
>
>
> time_duration(const time_duration<T, rep_type>& other)
> : ticks_(other.ticks_)
> {}
>
> time_duration(special_values sv) : ticks_(impl_type::from_special(sv))
> {}
>
> static duration_type unit()
> {
> return duration_type(0,0,0,1);
> }
>
> static tick_type ticks_per_second()
> {
> return rep_type::res_adjust();
> }
>
> static time_resolutions resolution()
> {
> return rep_type::resolution();
> }
>
> hour_type hours() const
> {
> return static_cast<hour_type>(ticks() / (3600*ticks_per_second()));
> }
>
> min_type minutes() const
> {
> return static_cast<min_type>((ticks() / (60*ticks_per_second())) % 60);
> }
>
> sec_type seconds() const
> {
> return static_cast<sec_type>((ticks()/ticks_per_second()) % 60);
> }
>
> sec_type total_seconds() const
> {
> return static_cast<sec_type>(ticks() / ticks_per_second());
> }
>
> tick_type total_milliseconds() const
> {
> if (ticks_per_second() < 1000) {
> return ticks() * (static_cast<tick_type>(1000) / ticks_per_second());
> }
> return ticks() / (ticks_per_second() / static_cast<tick_type>(1000)) ;
> }
>
> tick_type total_nanoseconds() const
> {
> if (ticks_per_second() < 1000000000) {
> return ticks() * (static_cast<tick_type>(1000000000) / ticks_per_second());
> }
> return ticks() / (ticks_per_second() / static_cast<tick_type>(1000000000)) ;
> }
>
> tick_type total_microseconds() const
> {
> if (ticks_per_second() < 1000000) {
> return ticks() * (static_cast<tick_type>(1000000) / ticks_per_second());
> }
> return ticks() / (ticks_per_second() / static_cast<tick_type>(1000000)) ;
> }
>
> fractional_seconds_type fractional_seconds() const
> {
> return (ticks() % ticks_per_second());
> }
>
> static unsigned short num_fractional_digits()
> {
> return rep_type::num_fractional_digits();
> }
> duration_type invert_sign() const
> {
> return duration_type(ticks_ * (-1));
> }
> bool is_negative() const
> {
> return ticks_ < 0;
> }
> bool operator<(const time_duration& rhs) const
> {
> return ticks_ < rhs.ticks_;
> }
> bool operator==(const time_duration& rhs) const
> {
> return ticks_ == rhs.ticks_;
> }
>
> duration_type operator-()const
> {
> return duration_type(ticks_ * (-1));
> }
> duration_type operator-(const duration_type& d) const
> {
> return duration_type(ticks_ - d.ticks_);
> }
> duration_type operator+(const duration_type& d) const
> {
> return duration_type(ticks_ + d.ticks_);
> }
> duration_type operator/(int divisor) const
> {
> return duration_type(ticks_ / divisor);
> }
> duration_type operator-=(const duration_type& d)
> {
> ticks_ = ticks_ - d.ticks_;
> return duration_type(ticks_);
> }
> duration_type operator+=(const duration_type& d)
> {
> ticks_ = ticks_ + d.ticks_;
> return duration_type(ticks_);
> }
>
> duration_type operator/=(int divisor)
> {
> ticks_ = ticks_ / divisor;
> return duration_type(ticks_);
> }
>
> duration_type operator*(int rhs) const
> {
> return duration_type(ticks_ * rhs);
> }
> duration_type operator*=(int divisor)
> {
> ticks_ = ticks_ * divisor;
> return duration_type(ticks_);
> }
> tick_type ticks() const
> {
> return traits_type::as_number(ticks_);
> }
>
>
> bool is_special()const
> {
> if(traits_type::is_adapted())
> {
> return ticks_.is_special();
> }
> else{
> return false;
> }
> }
>
> bool is_pos_infinity()const
> {
> if(traits_type::is_adapted())
> {
> return ticks_.is_pos_infinity();
> }
> else{
> return false;
> }
> }
>
> bool is_neg_infinity()const
> {
> if(traits_type::is_adapted())
> {
> return ticks_.is_neg_infinity();
> }
> else{
> return false;
> }
> }
>
> bool is_not_a_date_time()const
> {
> if(traits_type::is_adapted())
> {
> return ticks_.is_nan();
> }
> else{
> return false;
> }
> }
>
>
> impl_type get_rep()const
> {
> return ticks_;
> }
>
> protected:
> explicit time_duration(impl_type in) : ticks_(in) {}
> impl_type ticks_;
> };
>
>
>
>
>
>
>
> template<class base_duration, boost::int64_t frac_of_second>
> class subsecond_duration : public base_duration
> {
> public:
> typedef typename base_duration::impl_type impl_type;
> typedef typename base_duration::traits_type traits_type;
>
> private:
>
> static_assert((traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second % frac_of_second : frac_of_second % traits_type::ticks_per_second) == 0, "The base duration resolution must be a multiple of the subsecond duration resolution")
> ;
> static const boost::int64_t adjustment_ratio = (traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second / frac_of_second : frac_of_second / traits_type::ticks_per_second);
>
> public:
> explicit subsecond_duration(boost::int64_t ss) :
> base_duration(impl_type(traits_type::ticks_per_second >= frac_of_second ? ss * adjustment_ratio : ss / adjustment_ratio))
> {
> }
> };
>
>
>
>} }
># 17 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/time_resolution_traits.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/time_resolution_traits.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 14 "/usr/include/boost/date_time/time_resolution_traits.hpp" 2 3 4
>
># 1 "/usr/include/boost/date_time/int_adapter.hpp" 1 3 4
># 21 "/usr/include/boost/date_time/int_adapter.hpp" 3 4
>namespace boost {
>namespace date_time {
># 39 "/usr/include/boost/date_time/int_adapter.hpp" 3 4
>template<typename int_type_>
>class int_adapter {
>public:
> typedef int_type_ int_type;
> int_adapter(int_type v) :
> value_(v)
> {}
> static bool has_infinity()
> {
> return true;
> }
> static const int_adapter pos_infinity()
> {
> return (::std::numeric_limits<int_type>::max)();
> }
> static const int_adapter neg_infinity()
> {
> return (::std::numeric_limits<int_type>::min)();
> }
> static const int_adapter not_a_number()
> {
> return (::std::numeric_limits<int_type>::max)()-1;
> }
> static int_adapter max ()
> {
> return (::std::numeric_limits<int_type>::max)()-2;
> }
> static int_adapter min ()
> {
> return (::std::numeric_limits<int_type>::min)()+1;
> }
> static int_adapter from_special(special_values sv)
> {
> switch (sv) {
> case not_a_date_time: return not_a_number();
> case neg_infin: return neg_infinity();
> case pos_infin: return pos_infinity();
> case max_date_time: return (max)();
> case min_date_time: return (min)();
> default: return not_a_number();
> }
> }
> static bool is_inf(int_type v)
> {
> return (v == neg_infinity().as_number() ||
> v == pos_infinity().as_number());
> }
> static bool is_neg_inf(int_type v)
> {
> return (v == neg_infinity().as_number());
> }
> static bool is_pos_inf(int_type v)
> {
> return (v == pos_infinity().as_number());
> }
> static bool is_not_a_number(int_type v)
> {
> return (v == not_a_number().as_number());
> }
>
> static special_values to_special(int_type v)
> {
> if (is_not_a_number(v)) return not_a_date_time;
> if (is_neg_inf(v)) return neg_infin;
> if (is_pos_inf(v)) return pos_infin;
> return not_special;
> }
>
>
> static int_type maxcount()
> {
> return (::std::numeric_limits<int_type>::max)()-3;
> }
> bool is_infinity() const
> {
> return (value_ == neg_infinity().as_number() ||
> value_ == pos_infinity().as_number());
> }
> bool is_pos_infinity()const
> {
> return(value_ == pos_infinity().as_number());
> }
> bool is_neg_infinity()const
> {
> return(value_ == neg_infinity().as_number());
> }
> bool is_nan() const
> {
> return (value_ == not_a_number().as_number());
> }
> bool is_special() const
> {
> return(is_infinity() || is_nan());
> }
> bool operator==(const int_adapter& rhs) const
> {
> return (compare(rhs) == 0);
> }
> bool operator==(const int& rhs) const
> {
>
> bool is_signed = std::numeric_limits<int_type>::is_signed;
> if(!is_signed)
> {
> if(is_neg_inf(value_) && rhs == 0)
> {
> return false;
> }
> }
> return (compare(rhs) == 0);
> }
> bool operator!=(const int_adapter& rhs) const
> {
> return (compare(rhs) != 0);
> }
> bool operator!=(const int& rhs) const
> {
>
> bool is_signed = std::numeric_limits<int_type>::is_signed;
> if(!is_signed)
> {
> if(is_neg_inf(value_) && rhs == 0)
> {
> return true;
> }
> }
> return (compare(rhs) != 0);
> }
> bool operator<(const int_adapter& rhs) const
> {
> return (compare(rhs) == -1);
> }
> bool operator<(const int& rhs) const
> {
>
> bool is_signed = std::numeric_limits<int_type>::is_signed;
> if(!is_signed)
> {
> if(is_neg_inf(value_) && rhs == 0)
> {
> return true;
> }
> }
> return (compare(rhs) == -1);
> }
> bool operator>(const int_adapter& rhs) const
> {
> return (compare(rhs) == 1);
> }
> int_type as_number() const
> {
> return value_;
> }
>
> special_values as_special() const
> {
> return int_adapter::to_special(value_);
> }
># 205 "/usr/include/boost/date_time/int_adapter.hpp" 3 4
> template<class rhs_type>
> inline
> int_adapter operator+(const int_adapter<rhs_type>& rhs) const
> {
> if(is_special() || rhs.is_special())
> {
> if (is_nan() || rhs.is_nan())
> {
> return int_adapter::not_a_number();
> }
> if((is_pos_inf(value_) && rhs.is_neg_inf(rhs.as_number())) ||
> (is_neg_inf(value_) && rhs.is_pos_inf(rhs.as_number())) )
> {
> return int_adapter::not_a_number();
> }
> if (is_infinity())
> {
> return *this;
> }
> if (rhs.is_pos_inf(rhs.as_number()))
> {
> return int_adapter::pos_infinity();
> }
> if (rhs.is_neg_inf(rhs.as_number()))
> {
> return int_adapter::neg_infinity();
> }
> }
> return int_adapter<int_type>(value_ + rhs.as_number());
> }
>
> int_adapter operator+(const int_type rhs) const
> {
> if(is_special())
> {
> if (is_nan())
> {
> return int_adapter<int_type>(not_a_number());
> }
> if (is_infinity())
> {
> return *this;
> }
> }
> return int_adapter<int_type>(value_ + rhs);
> }
>
>
>
> template<class rhs_type>
> inline
> int_adapter operator-(const int_adapter<rhs_type>& rhs)const
> {
> if(is_special() || rhs.is_special())
> {
> if (is_nan() || rhs.is_nan())
> {
> return int_adapter::not_a_number();
> }
> if((is_pos_inf(value_) && rhs.is_pos_inf(rhs.as_number())) ||
> (is_neg_inf(value_) && rhs.is_neg_inf(rhs.as_number())) )
> {
> return int_adapter::not_a_number();
> }
> if (is_infinity())
> {
> return *this;
> }
> if (rhs.is_pos_inf(rhs.as_number()))
> {
> return int_adapter::neg_infinity();
> }
> if (rhs.is_neg_inf(rhs.as_number()))
> {
> return int_adapter::pos_infinity();
> }
> }
> return int_adapter<int_type>(value_ - rhs.as_number());
> }
> int_adapter operator-(const int_type rhs) const
> {
> if(is_special())
> {
> if (is_nan())
> {
> return int_adapter<int_type>(not_a_number());
> }
> if (is_infinity())
> {
> return *this;
> }
> }
> return int_adapter<int_type>(value_ - rhs);
> }
>
>
> int_adapter operator*(const int_adapter& rhs)const
> {
> if(this->is_special() || rhs.is_special())
> {
> return mult_div_specials(rhs);
> }
> return int_adapter<int_type>(value_ * rhs.value_);
> }
>
>
> int_adapter operator*(const int rhs) const
> {
> if(is_special())
> {
> return mult_div_specials(rhs);
> }
> return int_adapter<int_type>(value_ * rhs);
> }
>
>
> int_adapter operator/(const int_adapter& rhs)const
> {
> if(this->is_special() || rhs.is_special())
> {
> if(is_infinity() && rhs.is_infinity())
> {
> return int_adapter<int_type>(not_a_number());
> }
> if(rhs != 0)
> {
> return mult_div_specials(rhs);
> }
> else {
> return int_adapter<int_type>(value_ / rhs.value_);
> }
> }
> return int_adapter<int_type>(value_ / rhs.value_);
> }
>
>
> int_adapter operator/(const int rhs) const
> {
> if(is_special() && rhs != 0)
> {
> return mult_div_specials(rhs);
> }
> return int_adapter<int_type>(value_ / rhs);
> }
>
>
> int_adapter operator%(const int_adapter& rhs)const
> {
> if(this->is_special() || rhs.is_special())
> {
> if(is_infinity() && rhs.is_infinity())
> {
> return int_adapter<int_type>(not_a_number());
> }
> if(rhs != 0)
> {
> return mult_div_specials(rhs);
> }
> else {
> return int_adapter<int_type>(value_ % rhs.value_);
> }
> }
> return int_adapter<int_type>(value_ % rhs.value_);
> }
>
>
> int_adapter operator%(const int rhs) const
> {
> if(is_special() && rhs != 0)
> {
> return mult_div_specials(rhs);
> }
> return int_adapter<int_type>(value_ % rhs);
> }
>private:
> int_type value_;
>
>
> int compare(const int_adapter& rhs)const
> {
> if(this->is_special() || rhs.is_special())
> {
> if(this->is_nan() || rhs.is_nan()) {
> if(this->is_nan() && rhs.is_nan()) {
> return 0;
> }
> else {
> return 2;
> }
> }
> if((is_neg_inf(value_) && !is_neg_inf(rhs.value_)) ||
> (is_pos_inf(rhs.value_) && !is_pos_inf(value_)) )
> {
> return -1;
> }
> if((is_pos_inf(value_) && !is_pos_inf(rhs.value_)) ||
> (is_neg_inf(rhs.value_) && !is_neg_inf(value_)) ) {
> return 1;
> }
> }
> if(value_ < rhs.value_) return -1;
> if(value_ > rhs.value_) return 1;
>
> return 0;
> }
>
>
>
>
>
> int_adapter mult_div_specials(const int_adapter& rhs)const
> {
> int min_value;
>
> bool is_signed = std::numeric_limits<int_type>::is_signed;
> if(is_signed) {
> min_value = 0;
> }
> else {
> min_value = 1;
> }
> if(this->is_nan() || rhs.is_nan()) {
> return int_adapter<int_type>(not_a_number());
> }
> if((*this > 0 && rhs > 0) || (*this < min_value && rhs < min_value)) {
> return int_adapter<int_type>(pos_infinity());
> }
> if((*this > 0 && rhs < min_value) || (*this < min_value && rhs > 0)) {
> return int_adapter<int_type>(neg_infinity());
> }
>
> return int_adapter<int_type>(not_a_number());
> }
>
>
>
>
>
>
> int_adapter mult_div_specials(const int& rhs) const
> {
> int min_value;
>
> bool is_signed = std::numeric_limits<int_type>::is_signed;
> if(is_signed) {
> min_value = 0;
> }
> else {
> min_value = 1;
> }
> if(this->is_nan()) {
> return int_adapter<int_type>(not_a_number());
> }
> if((*this > 0 && rhs > 0) || (*this < min_value && rhs < 0)) {
> return int_adapter<int_type>(pos_infinity());
> }
> if((*this > 0 && rhs < 0) || (*this < min_value && rhs > 0)) {
> return int_adapter<int_type>(neg_infinity());
> }
>
> return int_adapter<int_type>(not_a_number());
> }
>
>};
>
>
>
>
>
>
> template<class charT, class traits, typename int_type>
> inline
> std::basic_ostream<charT, traits>&
> operator<<(std::basic_ostream<charT, traits>& os, const int_adapter<int_type>& ia)
> {
> if(ia.is_special()) {
>
> switch(ia.as_special())
> {
> case not_a_date_time:
> os << "not-a-number";
> break;
> case pos_infin:
> os << "+infinity";
> break;
> case neg_infin:
> os << "-infinity";
> break;
> default:
> os << "";
> }
> }
> else {
> os << ia.as_number();
> }
> return os;
> }
>
>
>
>} }
># 16 "/usr/include/boost/date_time/time_resolution_traits.hpp" 2 3 4
>
>
>namespace boost {
>namespace date_time {
>
>
> template <typename T>
>
>
> inline T absolute_value(T x)
> {
> return x < 0 ? -x : x;
> }
>
>
> struct time_resolution_traits_bi32_impl {
> typedef boost::int32_t int_type;
> typedef boost::int32_t impl_type;
> static int_type as_number(impl_type i){ return i;}
>
> static bool is_adapted() { return false;}
> };
>
> struct time_resolution_traits_adapted32_impl {
> typedef boost::int32_t int_type;
> typedef boost::date_time::int_adapter<boost::int32_t> impl_type;
> static int_type as_number(impl_type i){ return i.as_number();}
>
> static bool is_adapted() { return true;}
> };
>
> struct time_resolution_traits_bi64_impl {
> typedef boost::int64_t int_type;
> typedef boost::int64_t impl_type;
> static int_type as_number(impl_type i){ return i;}
>
> static bool is_adapted() { return false;}
> };
>
> struct time_resolution_traits_adapted64_impl {
> typedef boost::int64_t int_type;
> typedef boost::date_time::int_adapter<boost::int64_t> impl_type;
> static int_type as_number(impl_type i){ return i.as_number();}
>
> static bool is_adapted() { return true;}
> };
>
> template<typename frac_sec_type,
> time_resolutions res,
>
>
>
> typename frac_sec_type::int_type resolution_adjust,
>
> unsigned short frac_digits,
> typename v_type = boost::int32_t >
> class time_resolution_traits {
> public:
> typedef typename frac_sec_type::int_type fractional_seconds_type;
> typedef typename frac_sec_type::int_type tick_type;
> typedef typename frac_sec_type::impl_type impl_type;
> typedef v_type day_type;
> typedef v_type hour_type;
> typedef v_type min_type;
> typedef v_type sec_type;
>
>
> static fractional_seconds_type as_number(impl_type i)
> {
> return frac_sec_type::as_number(i);
> }
> static bool is_adapted()
> {
> return frac_sec_type::is_adapted();
> }
>
>
>
>
>
> static const fractional_seconds_type ticks_per_second = resolution_adjust;
>
>
> static time_resolutions resolution()
> {
> return res;
> }
> static unsigned short num_fractional_digits()
> {
> return frac_digits;
> }
> static fractional_seconds_type res_adjust()
> {
> return resolution_adjust;
> }
>
> static tick_type to_tick_count(hour_type hours,
> min_type minutes,
> sec_type seconds,
> fractional_seconds_type fs)
> {
> if(hours < 0 || minutes < 0 || seconds < 0 || fs < 0)
> {
> hours = absolute_value(hours);
> minutes = absolute_value(minutes);
> seconds = absolute_value(seconds);
> fs = absolute_value(fs);
> return (((((fractional_seconds_type(hours)*3600)
> + (fractional_seconds_type(minutes)*60)
> + seconds)*res_adjust()) + fs) * -1);
> }
>
> return (((fractional_seconds_type(hours)*3600)
> + (fractional_seconds_type(minutes)*60)
> + seconds)*res_adjust()) + fs;
> }
>
> };
>
> typedef time_resolution_traits<time_resolution_traits_adapted32_impl, milli, 1000, 3 > milli_res;
> typedef time_resolution_traits<time_resolution_traits_adapted64_impl, micro, 1000000, 6 > micro_res;
> typedef time_resolution_traits<time_resolution_traits_adapted64_impl, nano, 1000000000, 9 > nano_res;
>
>
>} }
># 18 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 1 3 4
># 17 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 3 4
># 1 "/usr/include/boost/date_time/date.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/date.hpp" 3 4
># 1 "/usr/include/boost/date_time/year_month_day.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/year_month_day.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
> template<typename YearType, typename MonthType, typename DayType>
> struct year_month_day_base {
> year_month_day_base(YearType year,
> MonthType month,
> DayType day);
> YearType year;
> MonthType month;
> DayType day;
> typedef YearType year_type;
> typedef MonthType month_type;
> typedef DayType day_type;
> };
>
>
>
> template<typename YearType, typename MonthType, typename DayType>
> inline
> year_month_day_base<YearType,MonthType,DayType>::year_month_day_base(YearType y,
> MonthType m,
> DayType d) :
> year(y),
> month(m),
> day(d)
> {}
>
>} }
># 14 "/usr/include/boost/date_time/date.hpp" 2 3 4
>
>
>namespace boost {
>namespace date_time {
># 52 "/usr/include/boost/date_time/date.hpp" 3 4
> template<class T, class calendar, class duration_type_>
> class date : private
> boost::less_than_comparable<T
> , boost::equality_comparable<T
> > >
> {
> public:
> typedef T date_type;
> typedef calendar calendar_type;
> typedef typename calendar::date_traits_type traits_type;
> typedef duration_type_ duration_type;
> typedef typename calendar::year_type year_type;
> typedef typename calendar::month_type month_type;
> typedef typename calendar::day_type day_type;
> typedef typename calendar::ymd_type ymd_type;
> typedef typename calendar::date_rep_type date_rep_type;
> typedef typename calendar::date_int_type date_int_type;
> typedef typename calendar::day_of_week_type day_of_week_type;
> date(year_type y, month_type m, day_type d)
> : days_(calendar::day_number(ymd_type(y, m, d)))
> {}
> date(const ymd_type& ymd)
> : days_(calendar::day_number(ymd))
> {}
>
> year_type year() const
> {
> ymd_type ymd = calendar::from_day_number(days_);
> return ymd.year;
> }
> month_type month() const
> {
> ymd_type ymd = calendar::from_day_number(days_);
> return ymd.month;
> }
> day_type day() const
> {
> ymd_type ymd = calendar::from_day_number(days_);
> return ymd.day;
> }
> day_of_week_type day_of_week() const
> {
> ymd_type ymd = calendar::from_day_number(days_);
> return calendar::day_of_week(ymd);
> }
> ymd_type year_month_day() const
> {
> return calendar::from_day_number(days_);
> }
> bool operator<(const date_type& rhs) const
> {
> return days_ < rhs.days_;
> }
> bool operator==(const date_type& rhs) const
> {
> return days_ == rhs.days_;
> }
>
> bool is_special()const
> {
> return(is_not_a_date() || is_infinity());
> }
>
> bool is_not_a_date() const
> {
> return traits_type::is_not_a_number(days_);
> }
>
> bool is_infinity() const
> {
> return traits_type::is_inf(days_);
> }
>
> bool is_pos_infinity() const
> {
> return traits_type::is_pos_inf(days_);
> }
>
> bool is_neg_infinity() const
> {
> return traits_type::is_neg_inf(days_);
> }
>
> special_values as_special() const
> {
> return traits_type::to_special(days_);
> }
> duration_type operator-(const date_type& d) const
> {
> if (!this->is_special() && !d.is_special())
> {
>
>
> typedef typename duration_type::duration_rep_type duration_rep_type;
> return duration_type(static_cast< duration_rep_type >(days_) - static_cast< duration_rep_type >(d.days_));
> }
> else
> {
>
> date_rep_type val = date_rep_type(days_) - date_rep_type(d.days_);
> return duration_type(val.as_special());
> }
> }
>
> date_type operator-(const duration_type& dd) const
> {
> if(dd.is_special())
> {
> return date_type(date_rep_type(days_) - dd.get_rep());
> }
> return date_type(date_rep_type(days_) - dd.days());
> }
> date_type operator-=(const duration_type& dd)
> {
> *this = *this - dd;
> return date_type(days_);
> }
> date_rep_type day_count() const
> {
> return days_;
> }
>
> date_type operator+(const duration_type& dd) const
> {
> if(dd.is_special())
> {
> return date_type(date_rep_type(days_) + dd.get_rep());
> }
> return date_type(date_rep_type(days_) + dd.days());
> }
> date_type operator+=(const duration_type& dd)
> {
> *this = *this + dd;
> return date_type(days_);
> }
>
>
> protected:
>
>
>
>
> explicit date(date_int_type days) : days_(days) {}
> explicit date(date_rep_type days) : days_(days.as_number()) {}
> date_int_type days_;
>
> };
>
>
>
>
>} }
># 18 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/period.hpp" 1 3 4
># 23 "/usr/include/boost/date_time/period.hpp" 3 4
>namespace boost {
>namespace date_time {
># 50 "/usr/include/boost/date_time/period.hpp" 3 4
> template<class point_rep, class duration_rep>
> class period : private
> boost::less_than_comparable<period<point_rep, duration_rep>
> , boost::equality_comparable< period<point_rep, duration_rep>
> > >
> {
> public:
> typedef point_rep point_type;
> typedef duration_rep duration_type;
>
> period(point_rep first_point, point_rep end_point);
> period(point_rep first_point, duration_rep len);
> point_rep begin() const;
> point_rep end() const;
> point_rep last() const;
> duration_rep length() const;
> bool is_null() const;
> bool operator==(const period& rhs) const;
> bool operator<(const period& rhs) const;
> void shift(const duration_rep& d);
> void expand(const duration_rep& d);
> bool contains(const point_rep& point) const;
> bool contains(const period& other) const;
> bool intersects(const period& other) const;
> bool is_adjacent(const period& other) const;
> bool is_before(const point_rep& point) const;
> bool is_after(const point_rep& point) const;
> period intersection(const period& other) const;
> period merge(const period& other) const;
> period span(const period& other) const;
> private:
> point_rep begin_;
> point_rep last_;
> };
>
>
>
>
> template<class point_rep, class duration_rep>
> inline
> period<point_rep,duration_rep>::period(point_rep first_point,
> point_rep end_point) :
> begin_(first_point),
> last_(end_point - duration_rep::unit())
> {}
>
>
>
>
> template<class point_rep, class duration_rep>
> inline
> period<point_rep,duration_rep>::period(point_rep first_point, duration_rep len) :
> begin_(first_point),
> last_(first_point + len-duration_rep::unit())
> { }
>
>
>
> template<class point_rep, class duration_rep>
> inline
> point_rep period<point_rep,duration_rep>::begin() const
> {
> return begin_;
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> point_rep period<point_rep,duration_rep>::end() const
> {
> return last_ + duration_rep::unit();
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> point_rep period<point_rep,duration_rep>::last() const
> {
> return last_;
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> bool period<point_rep,duration_rep>::is_null() const
> {
> return end() <= begin_;
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> duration_rep period<point_rep,duration_rep>::length() const
> {
> if(last_ < begin_){
> return last_+duration_rep::unit() - begin_;
> }
> else{
> return end() - begin_;
> }
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> bool period<point_rep,duration_rep>::operator==(const period& rhs) const
> {
> return ((begin_ == rhs.begin_) &&
> (last_ == rhs.last_));
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> bool period<point_rep,duration_rep>::operator<(const period& rhs) const
> {
> return (last_ < rhs.begin_);
> }
>
>
>
> template<class point_rep, class duration_rep>
> inline
> void period<point_rep,duration_rep>::shift(const duration_rep& d)
> {
> begin_ = begin_ + d;
> last_ = last_ + d;
> }
># 198 "/usr/include/boost/date_time/period.hpp" 3 4
> template<class point_rep, class duration_rep>
> inline
> void period<point_rep,duration_rep>::expand(const duration_rep& d)
> {
> begin_ = begin_ - d;
> last_ = last_ + d;
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> bool period<point_rep,duration_rep>::contains(const point_rep& point) const
> {
> return ((point >= begin_) &&
> (point <= last_));
> }
>
>
>
> template<class point_rep, class duration_rep>
> inline
> bool period<point_rep,duration_rep>::contains(const period<point_rep,duration_rep>& other) const
> {
> return ((begin_ <= other.begin_) && (last_ >= other.last_));
> }
># 234 "/usr/include/boost/date_time/period.hpp" 3 4
> template<class point_rep, class duration_rep>
> inline
> bool
> period<point_rep,duration_rep>::is_adjacent(const period<point_rep,duration_rep>& other) const
> {
> return (other.begin() == end() ||
> begin_ == other.end());
> }
># 253 "/usr/include/boost/date_time/period.hpp" 3 4
> template<class point_rep, class duration_rep>
> inline
> bool
> period<point_rep,duration_rep>::is_after(const point_rep& t) const
> {
> if (is_null())
> {
> return false;
> }
>
> return t < begin_;
> }
># 275 "/usr/include/boost/date_time/period.hpp" 3 4
> template<class point_rep, class duration_rep>
> inline
> bool
> period<point_rep,duration_rep>::is_before(const point_rep& t) const
> {
> if (is_null())
> {
> return false;
> }
>
> return last_ < t;
> }
># 300 "/usr/include/boost/date_time/period.hpp" 3 4
> template<class point_rep, class duration_rep>
> inline
> bool period<point_rep,duration_rep>::intersects(const period<point_rep,duration_rep>& other) const
> {
> return ( contains(other.begin_) ||
> other.contains(begin_) ||
> ((other.begin_ < begin_) && (other.last_ >= begin_)));
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> period<point_rep,duration_rep>
> period<point_rep,duration_rep>::intersection(const period<point_rep,duration_rep>& other) const
> {
> if (begin_ > other.begin_) {
> if (last_ <= other.last_) {
> return *this;
> }
>
> return period<point_rep,duration_rep>(begin_, other.end());
> }
> else {
> if (last_ <= other.last_) {
> return period<point_rep,duration_rep>(other.begin_, this->end());
> }
>
> return other;
> }
>
> }
>
>
>
>
> template<class point_rep, class duration_rep>
> inline
> period<point_rep,duration_rep>
> period<point_rep,duration_rep>::merge(const period<point_rep,duration_rep>& other) const
> {
> if (this->intersects(other)) {
> if (begin_ < other.begin_) {
> return period<point_rep,duration_rep>(begin_, last_ > other.last_ ? this->end() : other.end());
> }
>
> return period<point_rep,duration_rep>(other.begin_, last_ > other.last_ ? this->end() : other.end());
>
> }
> return period<point_rep,duration_rep>(begin_,begin_);
> }
># 362 "/usr/include/boost/date_time/period.hpp" 3 4
> template<class point_rep, class duration_rep>
> inline
> period<point_rep,duration_rep>
> period<point_rep,duration_rep>::span(const period<point_rep,duration_rep>& other) const
> {
> point_rep start((begin_ < other.begin_) ? begin() : other.begin());
> point_rep newend((last_ < other.last_) ? other.end() : this->end());
> return period<point_rep,duration_rep>(start, newend);
> }
>
>
>} }
># 19 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 3 4
># 1 "/usr/include/boost/date_time/constrained_value.hpp" 1 3 4
># 19 "/usr/include/boost/date_time/constrained_value.hpp" 3 4
>namespace boost {
>
>
>namespace CV {
>
> enum violation_enum {min_violation, max_violation};
># 41 "/usr/include/boost/date_time/constrained_value.hpp" 3 4
> template<class value_policies>
> class constrained_value {
> public:
> typedef typename value_policies::value_type value_type;
>
> constrained_value(value_type value) : value_((min)())
> {
> assign(value);
> }
> constrained_value& operator=(value_type v)
> {
> assign(v);
> return *this;
> }
>
> static value_type max () {return (value_policies::max)();}
>
> static value_type min () {return (value_policies::min)();}
>
> operator value_type() const {return value_;}
> protected:
> value_type value_;
> private:
> void assign(value_type value)
> {
>
>
> if (value+1 < (min)()+1) {
> value_policies::on_error(value_, value, min_violation);
> return;
> }
> if (value > (max)()) {
> value_policies::on_error(value_, value, max_violation);
> return;
> }
> value_ = value;
> }
>};
>
>
> template<typename rep_type, rep_type min_value,
> rep_type max_value, class exception_type>
> class simple_exception_policy
> {
> struct exception_wrapper : public exception_type
> {
>
>
>
>
> operator std::out_of_range () const
> {
>
> return std::out_of_range("constrained value boundary has been violated");
> }
> };
>
> typedef typename mpl::if_<
> is_base_of< std::exception, exception_type >,
> exception_type,
> exception_wrapper
> >::type actual_exception_type;
>
> public:
> typedef rep_type value_type;
> static rep_type min () { return min_value; }
> static rep_type max () { return max_value; }
> static void on_error(rep_type, rep_type, violation_enum)
> {
> boost::throw_exception(actual_exception_type());
> }
> };
>
>
>
>} }
># 13 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/date_defs.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/date_defs.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
> enum weekdays {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};
>
>
> enum months_of_year {Jan=1,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec,NotAMonth,NumMonths};
>
>} }
># 14 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 2 3 4
>
>
>
>
>namespace boost {
>namespace gregorian {
>
>
> using date_time::Sunday;
> using date_time::Monday;
> using date_time::Tuesday;
> using date_time::Wednesday;
> using date_time::Thursday;
> using date_time::Friday;
> using date_time::Saturday;
>
>
>
> struct bad_weekday : public std::out_of_range
> {
> bad_weekday() : std::out_of_range(std::string("Weekday is out of range 0..6")) {}
> };
> typedef CV::simple_exception_policy<unsigned short, 0, 6, bad_weekday> greg_weekday_policies;
> typedef CV::constrained_value<greg_weekday_policies> greg_weekday_rep;
>
>
>
> class greg_weekday : public greg_weekday_rep {
> public:
> typedef boost::date_time::weekdays weekday_enum;
> greg_weekday(unsigned short day_of_week_num) :
> greg_weekday_rep(day_of_week_num)
> {}
>
> unsigned short as_number() const {return value_;}
> const char* as_short_string() const;
> const char* as_long_string() const;
>
> const wchar_t* as_short_wstring() const;
> const wchar_t* as_long_wstring() const;
>
> weekday_enum as_enum() const {return static_cast<weekday_enum>(value_);}
>
>
> };
>
>
>
>} }
># 14 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_day_of_year.hpp" 1 3 4
># 16 "/usr/include/boost/date_time/gregorian/greg_day_of_year.hpp" 3 4
>namespace boost {
>namespace gregorian {
>
>
> struct bad_day_of_year : public std::out_of_range
> {
> bad_day_of_year() :
> std::out_of_range(std::string("Day of year value is out of range 1..366"))
> {}
> };
>
>
> typedef CV::simple_exception_policy<unsigned short,1,366,bad_day_of_year> greg_day_of_year_policies;
>
>
> typedef CV::constrained_value<greg_day_of_year_policies> greg_day_of_year_rep;
>
>
>} }
># 15 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian_calendar.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/gregorian_calendar.hpp" 3 4
>namespace boost {
>namespace date_time {
># 27 "/usr/include/boost/date_time/gregorian_calendar.hpp" 3 4
> template<typename ymd_type_, typename date_int_type_>
> class gregorian_calendar_base {
> public:
>
> typedef ymd_type_ ymd_type;
>
> typedef typename ymd_type::month_type month_type;
>
> typedef typename ymd_type::day_type day_type;
>
> typedef typename ymd_type::year_type year_type;
>
> typedef date_int_type_ date_int_type;
>
>
> static unsigned short day_of_week(const ymd_type& ymd);
> static int week_number(const ymd_type&ymd);
>
> static date_int_type day_number(const ymd_type& ymd);
> static date_int_type julian_day_number(const ymd_type& ymd);
> static date_int_type modjulian_day_number(const ymd_type& ymd);
> static ymd_type from_day_number(date_int_type);
> static ymd_type from_julian_day_number(date_int_type);
> static ymd_type from_modjulian_day_number(date_int_type);
> static bool is_leap_year(year_type);
> static unsigned short end_of_month_day(year_type y, month_type m);
> static ymd_type epoch();
> static unsigned short days_in_week();
>
> };
>
>
>
>} }
>
>
># 1 "/usr/include/boost/date_time/gregorian_calendar.ipp" 1 3 4
># 14 "/usr/include/boost/date_time/gregorian_calendar.ipp" 3 4
>namespace boost {
>namespace date_time {
>
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> unsigned short
> gregorian_calendar_base<ymd_type_,date_int_type_>::day_of_week(const ymd_type& ymd) {
> unsigned short a = static_cast<unsigned short>((14-ymd.month)/12);
> unsigned short y = static_cast<unsigned short>(ymd.year - a);
> unsigned short m = static_cast<unsigned short>(ymd.month + 12*a - 2);
> unsigned short d = static_cast<unsigned short>((ymd.day + y + (y/4) - (y/100) + (y/400) + (31*m)/12) % 7);
>
> return d;
> }
>
>
>
>
>
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> int
> gregorian_calendar_base<ymd_type_,date_int_type_>::week_number(const ymd_type& ymd) {
> unsigned long julianbegin = julian_day_number(ymd_type(ymd.year,1,1));
> unsigned long juliantoday = julian_day_number(ymd);
> unsigned long day = (julianbegin + 3) % 7;
> unsigned long week = (juliantoday + day - julianbegin + 4)/7;
>
> if ((week >= 1) && (week <= 52)) {
> return week;
> }
>
> if (week == 53) {
> if((day==6) ||(day == 5 && is_leap_year(ymd.year))) {
> return week;
> } else {
> return 1;
> }
> }
>
> else if (week == 0) {
> julianbegin = julian_day_number(ymd_type(static_cast<unsigned short>(ymd.year-1),1,1));
> juliantoday = julian_day_number(ymd);
> day = (julianbegin + 3) % 7;
> week = (juliantoday + day - julianbegin + 4)/7;
> return week;
> }
>
> return week;
>
> }
>
>
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> date_int_type_
> gregorian_calendar_base<ymd_type_,date_int_type_>::day_number(const ymd_type& ymd)
> {
> unsigned short a = static_cast<unsigned short>((14-ymd.month)/12);
> unsigned short y = static_cast<unsigned short>(ymd.year + 4800 - a);
> unsigned short m = static_cast<unsigned short>(ymd.month + 12*a - 3);
> unsigned long d = ymd.day + ((153*m + 2)/5) + 365*y + (y/4) - (y/100) + (y/400) - 32045;
> return d;
> }
>
>
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> date_int_type_
> gregorian_calendar_base<ymd_type_,date_int_type_>::julian_day_number(const ymd_type& ymd)
> {
> return day_number(ymd);
> }
>
>
>
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> date_int_type_
> gregorian_calendar_base<ymd_type_,date_int_type_>::modjulian_day_number(const ymd_type& ymd)
> {
> return julian_day_number(ymd)-2400001;
> }
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> ymd_type_
> gregorian_calendar_base<ymd_type_,date_int_type_>::from_day_number(date_int_type dayNumber)
> {
> date_int_type a = dayNumber + 32044;
> date_int_type b = (4*a + 3)/146097;
> date_int_type c = a-((146097*b)/4);
> date_int_type d = (4*c + 3)/1461;
> date_int_type e = c - (1461*d)/4;
> date_int_type m = (5*e + 2)/153;
> unsigned short day = static_cast<unsigned short>(e - ((153*m + 2)/5) + 1);
> unsigned short month = static_cast<unsigned short>(m + 3 - 12 * (m/10));
> year_type year = static_cast<unsigned short>(100*b + d - 4800 + (m/10));
>
>
> return ymd_type(static_cast<unsigned short>(year),month,day);
> }
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> ymd_type_
> gregorian_calendar_base<ymd_type_,date_int_type_>::from_julian_day_number(date_int_type dayNumber)
> {
> date_int_type a = dayNumber + 32044;
> date_int_type b = (4*a+3)/146097;
> date_int_type c = a - ((146097*b)/4);
> date_int_type d = (4*c + 3)/1461;
> date_int_type e = c - ((1461*d)/4);
> date_int_type m = (5*e + 2)/153;
> unsigned short day = static_cast<unsigned short>(e - ((153*m + 2)/5) + 1);
> unsigned short month = static_cast<unsigned short>(m + 3 - 12 * (m/10));
> year_type year = static_cast<year_type>(100*b + d - 4800 + (m/10));
>
>
> return ymd_type(year,month,day);
> }
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> ymd_type_
> gregorian_calendar_base<ymd_type_,date_int_type_>::from_modjulian_day_number(date_int_type dayNumber) {
> date_int_type jd = dayNumber + 2400001;
> return from_julian_day_number(jd);
> }
>
>
>
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> bool
> gregorian_calendar_base<ymd_type_,date_int_type_>::is_leap_year(year_type year)
> {
>
> return (!(year % 4)) && ((year % 100) || (!(year % 400)));
> }
>
>
>
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> unsigned short
> gregorian_calendar_base<ymd_type_,date_int_type_>::end_of_month_day(year_type year,
> month_type month)
> {
> switch (month) {
> case 2:
> if (is_leap_year(year)) {
> return 29;
> } else {
> return 28;
> };
> case 4:
> case 6:
> case 9:
> case 11:
> return 30;
> default:
> return 31;
> };
>
> }
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> ymd_type_
> gregorian_calendar_base<ymd_type_,date_int_type_>::epoch()
> {
> return ymd_type(1400,1,1);
> }
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> unsigned short
> gregorian_calendar_base<ymd_type_,date_int_type_>::days_in_week()
> {
> return 7;
> }
>
>
>} }
># 64 "/usr/include/boost/date_time/gregorian_calendar.hpp" 2 3 4
># 16 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 1 3 4
># 14 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_day.hpp" 1 3 4
># 16 "/usr/include/boost/date_time/gregorian/greg_day.hpp" 3 4
>namespace boost {
>namespace gregorian {
>
>
> struct bad_day_of_month : public std::out_of_range
> {
> bad_day_of_month() :
> std::out_of_range(std::string("Day of month value is out of range 1..31"))
> {}
>
> bad_day_of_month(const std::string& s) :
> std::out_of_range(s)
> {}
> };
>
> typedef CV::simple_exception_policy<unsigned short, 1, 31, bad_day_of_month> greg_day_policies;
>
>
> typedef CV::constrained_value<greg_day_policies> greg_day_rep;
>
>
>
>
>
>
>
> class greg_day : public greg_day_rep {
> public:
> greg_day(unsigned short day_of_month) : greg_day_rep(day_of_month) {}
> unsigned short as_number() const {return value_;}
> operator unsigned short() const {return value_;}
> private:
>
> };
>
>
>
>} }
># 15 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_year.hpp" 1 3 4
># 16 "/usr/include/boost/date_time/gregorian/greg_year.hpp" 3 4
>namespace boost {
>namespace gregorian {
>
>
> struct bad_year : public std::out_of_range
> {
> bad_year() :
> std::out_of_range(std::string("Year is out of valid range: 1400..10000"))
> {}
> };
>
> typedef CV::simple_exception_policy<unsigned short, 1400, 10000, bad_year> greg_year_policies;
>
>
> typedef CV::constrained_value<greg_year_policies> greg_year_rep;
># 39 "/usr/include/boost/date_time/gregorian/greg_year.hpp" 3 4
> class greg_year : public greg_year_rep {
> public:
> greg_year(unsigned short year) : greg_year_rep(year) {}
> operator unsigned short() const {return value_;}
> private:
>
> };
>
>
>
>} }
># 16 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_month.hpp" 1 3 4
># 20 "/usr/include/boost/date_time/gregorian/greg_month.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cctype" 1 3 4
># 39 "/usr/include/c++/4.8.2/cctype" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cctype" 3
># 21 "/usr/include/boost/date_time/gregorian/greg_month.hpp" 2 3 4
>
>namespace boost {
>namespace gregorian {
>
> typedef date_time::months_of_year months_of_year;
>
>
> using date_time::Jan;
> using date_time::Feb;
> using date_time::Mar;
> using date_time::Apr;
> using date_time::May;
> using date_time::Jun;
> using date_time::Jul;
> using date_time::Aug;
> using date_time::Sep;
> using date_time::Oct;
> using date_time::Nov;
> using date_time::Dec;
> using date_time::NotAMonth;
> using date_time::NumMonths;
>
>
> struct bad_month : public std::out_of_range
> {
> bad_month() : std::out_of_range(std::string("Month number is out of range 1..12")) {}
> };
>
> typedef CV::simple_exception_policy<unsigned short, 1, 12, bad_month> greg_month_policies;
>
> typedef CV::constrained_value<greg_month_policies> greg_month_rep;
>
>
>
> class greg_month : public greg_month_rep {
> public:
> typedef date_time::months_of_year month_enum;
> typedef std::map<std::string, unsigned short> month_map_type;
> typedef boost::shared_ptr<month_map_type> month_map_ptr_type;
>
> greg_month(month_enum theMonth) :
> greg_month_rep(static_cast<greg_month_rep::value_type>(theMonth)) {}
>
> greg_month(unsigned short theMonth) : greg_month_rep(theMonth) {}
>
> operator unsigned short() const {return value_;}
>
> unsigned short as_number() const {return value_;}
> month_enum as_enum() const {return static_cast<month_enum>(value_);}
> const char* as_short_string() const;
> const char* as_long_string() const;
>
> const wchar_t* as_short_wstring() const;
> const wchar_t* as_long_wstring() const;
>
>
> static month_map_ptr_type get_month_map_ptr();
>
>
>
> const char* as_short_string(char) const
> {
> return as_short_string();
> }
> const char* as_long_string(char) const
> {
> return as_long_string();
> }
>
> const wchar_t* as_short_string(wchar_t) const
> {
> return as_short_wstring();
> }
> const wchar_t* as_long_string(wchar_t) const
> {
> return as_long_wstring();
> }
>
> };
>
>} }
># 17 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 2 3 4
>
>namespace boost {
>namespace gregorian {
>
> typedef date_time::year_month_day_base<greg_year,
> greg_month,
> greg_day> greg_year_month_day;
>
>
>
>} }
># 17 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
>
>
>namespace boost {
>namespace gregorian {
>
>
> typedef date_time::int_adapter<uint32_t> fancy_date_rep;
>
>
> class gregorian_calendar :
> public date_time::gregorian_calendar_base<greg_year_month_day, fancy_date_rep::int_type> {
> public:
>
> typedef greg_weekday day_of_week_type;
>
> typedef greg_day_of_year_rep day_of_year_type;
>
> typedef fancy_date_rep date_rep_type;
>
> typedef fancy_date_rep date_traits_type;
>
>
> private:
> };
>
>} }
># 20 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 3 4
># 1 "/usr/include/boost/date_time/date_duration.hpp" 1 3 4
># 16 "/usr/include/boost/date_time/date_duration.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
>
> template<class duration_rep_traits>
> class date_duration : private
> boost::less_than_comparable1< date_duration< duration_rep_traits >
> , boost::equality_comparable1< date_duration< duration_rep_traits >
> , boost::addable1< date_duration< duration_rep_traits >
> , boost::subtractable1< date_duration< duration_rep_traits >
> , boost::dividable2< date_duration< duration_rep_traits >, int
> > > > > >
> {
> public:
> typedef typename duration_rep_traits::int_type duration_rep_type;
> typedef typename duration_rep_traits::impl_type duration_rep;
>
>
> explicit date_duration(duration_rep day_count) : days_(day_count) {}
>
>
>
> date_duration(special_values sv) :
> days_(duration_rep::from_special(sv))
> {}
>
>
>
> date_duration(const date_duration<duration_rep_traits>& other) :
> days_(other.days_)
> {}
>
>
> duration_rep get_rep()const
> {
> return days_;
> }
> bool is_special()const
> {
> return days_.is_special();
> }
>
> duration_rep_type days() const
> {
> return duration_rep_traits::as_number(days_);
> }
>
> static date_duration unit()
> {
> return date_duration<duration_rep_traits>(1);
> }
>
> bool operator==(const date_duration& rhs) const
> {
> return days_ == rhs.days_;
> }
>
> bool operator<(const date_duration& rhs) const
> {
> return days_ < rhs.days_;
> }
>
>
>
>
>
>
>
> date_duration& operator-=(const date_duration& rhs)
> {
>
> days_ = days_ - rhs.days_;
> return *this;
> }
>
> date_duration& operator+=(const date_duration& rhs)
> {
> days_ = days_ + rhs.days_;
> return *this;
> }
>
>
> date_duration operator-() const
> {
> return date_duration<duration_rep_traits>(get_rep() * (-1));
> }
>
> date_duration& operator/=(int divisor)
> {
> days_ = days_ / divisor;
> return *this;
> }
>
>
> bool is_negative() const
> {
> return days_ < 0;
> }
>
> private:
> duration_rep days_;
> };
>
>
>
>
>
> struct duration_traits_long
> {
> typedef long int_type;
> typedef long impl_type;
> static int_type as_number(impl_type i) { return i; }
> };
>
>
>
>
> struct duration_traits_adapted
> {
> typedef long int_type;
> typedef boost::date_time::int_adapter<long> impl_type;
> static int_type as_number(impl_type i) { return i.as_number(); }
> };
>
>
>} }
># 13 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 2 3 4
>
>
>
>namespace boost {
>namespace gregorian {
>
>
> typedef boost::date_time::duration_traits_adapted date_duration_rep;
>
>
>
>
> class date_duration :
> public boost::date_time::date_duration< date_duration_rep >
> {
> typedef boost::date_time::date_duration< date_duration_rep > base_type;
>
> public:
> typedef base_type::duration_rep duration_rep;
>
>
> explicit date_duration(duration_rep day_count = 0) : base_type(day_count) {}
>
>
> date_duration(date_time::special_values sv) : base_type(sv) {}
>
>
> date_duration(const date_duration& other) : base_type(static_cast< base_type const& >(other))
> {}
>
>
> date_duration(const base_type& other) : base_type(other)
> {}
>
>
>
>
>
> bool operator== (const date_duration& rhs) const
> {
> return base_type::operator== (rhs);
> }
> bool operator!= (const date_duration& rhs) const
> {
> return !operator== (rhs);
> }
> bool operator< (const date_duration& rhs) const
> {
> return base_type::operator< (rhs);
> }
> bool operator> (const date_duration& rhs) const
> {
> return !(base_type::operator< (rhs) || base_type::operator== (rhs));
> }
> bool operator<= (const date_duration& rhs) const
> {
> return (base_type::operator< (rhs) || base_type::operator== (rhs));
> }
> bool operator>= (const date_duration& rhs) const
> {
> return !base_type::operator< (rhs);
> }
>
>
> date_duration& operator-= (const date_duration& rhs)
> {
> base_type::operator-= (rhs);
> return *this;
> }
> friend date_duration operator- (date_duration rhs, date_duration const& lhs)
> {
> rhs -= lhs;
> return rhs;
> }
>
>
> date_duration& operator+= (const date_duration& rhs)
> {
> base_type::operator+= (rhs);
> return *this;
> }
> friend date_duration operator+ (date_duration rhs, date_duration const& lhs)
> {
> rhs += lhs;
> return rhs;
> }
>
>
> date_duration operator- ()const
> {
> return date_duration(get_rep() * (-1));
> }
>
>
> date_duration& operator/= (int divisor)
> {
> base_type::operator/= (divisor);
> return *this;
> }
> friend date_duration operator/ (date_duration rhs, int lhs)
> {
> rhs /= lhs;
> return rhs;
> }
>
>
> static date_duration unit()
> {
> return date_duration(base_type::unit().get_rep());
> }
> };
>
>
> typedef date_duration days;
>
>} }
>
>
># 1 "/usr/include/boost/date_time/date_duration_types.hpp" 1 3 4
># 16 "/usr/include/boost/date_time/date_duration_types.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
>
> template <class duration_config>
> class weeks_duration : public date_duration<duration_config> {
> public:
> weeks_duration(typename duration_config::impl_type w)
> : date_duration<duration_config>(w * 7) {}
> weeks_duration(special_values sv)
> : date_duration<duration_config>(sv) {}
> };
>
>
> template<class t>
> class years_duration;
>
>
>
>
>
>
> template<class base_config>
> class months_duration
> {
> private:
> typedef typename base_config::int_rep int_rep;
> typedef typename int_rep::int_type int_type;
> typedef typename base_config::date_type date_type;
> typedef typename date_type::duration_type duration_type;
> typedef typename base_config::month_adjustor_type month_adjustor_type;
> typedef months_duration<base_config> months_type;
> typedef years_duration<base_config> years_type;
> public:
> months_duration(int_rep num) : _m(num) {}
> months_duration(special_values sv) : _m(sv)
> {
> _m = int_rep::from_special(sv);
> }
> int_rep number_of_months() const { return _m; }
>
> duration_type get_neg_offset(const date_type& d) const
> {
> month_adjustor_type m_adj(_m.as_number());
> return duration_type(m_adj.get_neg_offset(d));
> }
> duration_type get_offset(const date_type& d) const
> {
> month_adjustor_type m_adj(_m.as_number());
> return duration_type(m_adj.get_offset(d));
> }
> bool operator==(const months_type& rhs) const
> {
> return(_m == rhs._m);
> }
> bool operator!=(const months_type& rhs) const
> {
> return(_m != rhs._m);
> }
> months_type operator+(const months_type& rhs)const
> {
> return months_type(_m + rhs._m);
> }
> months_type& operator+=(const months_type& rhs)
> {
> _m = _m + rhs._m;
> return *this;
> }
> months_type operator-(const months_type& rhs)const
> {
> return months_type(_m - rhs._m);
> }
> months_type& operator-=(const months_type& rhs)
> {
> _m = _m - rhs._m;
> return *this;
> }
> months_type operator*(const int_type rhs)const
> {
> return months_type(_m * rhs);
> }
> months_type& operator*=(const int_type rhs)
> {
> _m = _m * rhs;
> return *this;
> }
> months_type operator/(const int_type rhs)const
> {
> return months_type(_m / rhs);
> }
> months_type& operator/=(const int_type rhs)
> {
> _m = _m / rhs;
> return *this;
> }
> months_type operator+(const years_type& y)const
> {
> return months_type(y.number_of_years() * 12 + _m);
> }
> months_type& operator+=(const years_type& y)
> {
> _m = y.number_of_years() * 12 + _m;
> return *this;
> }
> months_type operator-(const years_type& y) const
> {
> return months_type(_m - y.number_of_years() * 12);
> }
> months_type& operator-=(const years_type& y)
> {
> _m = _m - y.number_of_years() * 12;
> return *this;
> }
>
>
> friend date_type operator+(const date_type& d, const months_type& m)
> {
> return d + m.get_offset(d);
> }
> friend date_type operator+=(date_type& d, const months_type& m)
> {
> return d += m.get_offset(d);
> }
> friend date_type operator-(const date_type& d, const months_type& m)
> {
>
> return d + m.get_neg_offset(d);
> }
> friend date_type operator-=(date_type& d, const months_type& m)
> {
>
> return d += m.get_neg_offset(d);
> }
>
> private:
> int_rep _m;
> };
>
>
>
>
>
>
>
> template<class base_config>
> class years_duration
> {
> private:
> typedef typename base_config::int_rep int_rep;
> typedef typename int_rep::int_type int_type;
> typedef typename base_config::date_type date_type;
> typedef typename date_type::duration_type duration_type;
> typedef typename base_config::month_adjustor_type month_adjustor_type;
> typedef years_duration<base_config> years_type;
> typedef months_duration<base_config> months_type;
> public:
> years_duration(int_rep num) : _y(num) {}
> years_duration(special_values sv) : _y(sv)
> {
> _y = int_rep::from_special(sv);
> }
> int_rep number_of_years() const { return _y; }
>
> duration_type get_neg_offset(const date_type& d) const
> {
> month_adjustor_type m_adj(_y.as_number() * 12);
> return duration_type(m_adj.get_neg_offset(d));
> }
> duration_type get_offset(const date_type& d) const
> {
> month_adjustor_type m_adj(_y.as_number() * 12);
> return duration_type(m_adj.get_offset(d));
> }
> bool operator==(const years_type& rhs) const
> {
> return(_y == rhs._y);
> }
> bool operator!=(const years_type& rhs) const
> {
> return(_y != rhs._y);
> }
> years_type operator+(const years_type& rhs)const
> {
> return years_type(_y + rhs._y);
> }
> years_type& operator+=(const years_type& rhs)
> {
> _y = _y + rhs._y;
> return *this;
> }
> years_type operator-(const years_type& rhs)const
> {
> return years_type(_y - rhs._y);
> }
> years_type& operator-=(const years_type& rhs)
> {
> _y = _y - rhs._y;
> return *this;
> }
> years_type operator*(const int_type rhs)const
> {
> return years_type(_y * rhs);
> }
> years_type& operator*=(const int_type rhs)
> {
> _y = _y * rhs;
> return *this;
> }
> years_type operator/(const int_type rhs)const
> {
> return years_type(_y / rhs);
> }
> years_type& operator/=(const int_type rhs)
> {
> _y = _y / rhs;
> return *this;
> }
> months_type operator+(const months_type& m) const
> {
> return(months_type(_y * 12 + m.number_of_months()));
> }
> months_type operator-(const months_type& m) const
> {
> return(months_type(_y * 12 - m.number_of_months()));
> }
>
>
> friend date_type operator+(const date_type& d, const years_type& y)
> {
> return d + y.get_offset(d);
> }
> friend date_type operator+=(date_type& d, const years_type& y)
> {
> return d += y.get_offset(d);
> }
> friend date_type operator-(const date_type& d, const years_type& y)
> {
>
> return d + y.get_neg_offset(d);
> }
> friend date_type operator-=(date_type& d, const years_type& y)
> {
>
> return d += y.get_neg_offset(d);
> }
>
> private:
> int_rep _y;
> };
>
>}}
># 132 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 2 3 4
># 21 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
>
># 1 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_date.hpp" 1 3 4
># 18 "/usr/include/boost/date_time/gregorian/greg_date.hpp" 3 4
>namespace boost {
>namespace gregorian {
>
>
> using date_time::special_values;
> using date_time::not_special;
> using date_time::neg_infin;
> using date_time::pos_infin;
> using date_time::not_a_date_time;
> using date_time::max_date_time;
> using date_time::min_date_time;
># 37 "/usr/include/boost/date_time/gregorian/greg_date.hpp" 3 4
> class date : public date_time::date<date, gregorian_calendar, date_duration>
> {
> public:
> typedef gregorian_calendar::year_type year_type;
> typedef gregorian_calendar::month_type month_type;
> typedef gregorian_calendar::day_type day_type;
> typedef gregorian_calendar::day_of_year_type day_of_year_type;
> typedef gregorian_calendar::ymd_type ymd_type;
> typedef gregorian_calendar::date_rep_type date_rep_type;
> typedef gregorian_calendar::date_int_type date_int_type;
> typedef date_duration duration_type;
>
>
> date():
> date_time::date<date, gregorian_calendar, date_duration>(date_rep_type::from_special(not_a_date_time))
> {}
>
>
> date(year_type y, month_type m, day_type d)
> : date_time::date<date, gregorian_calendar, date_duration>(y, m, d)
> {
> if (gregorian_calendar::end_of_month_day(y, m) < d) {
> boost::throw_exception(bad_day_of_month(std::string("Day of month is not valid for year")));
> }
> }
>
> explicit date(const ymd_type& ymd)
> : date_time::date<date, gregorian_calendar, date_duration>(ymd)
> {}
>
> explicit date(const date_int_type& rhs):
> date_time::date<date,gregorian_calendar, date_duration>(rhs)
> {}
>
> explicit date(date_rep_type rhs):
> date_time::date<date,gregorian_calendar, date_duration>(rhs)
> {}
>
> explicit date(special_values sv):
> date_time::date<date, gregorian_calendar, date_duration>(date_rep_type::from_special(sv))
> {
> if (sv == min_date_time)
> {
> *this = date(1400, 1, 1);
> }
> if (sv == max_date_time)
> {
> *this = date(9999, 12, 31);
> }
>
> }
>
> date_int_type julian_day() const
> {
> ymd_type ymd = year_month_day();
> return gregorian_calendar::julian_day_number(ymd);
> }
>
> day_of_year_type day_of_year() const
> {
> date start_of_year(year(), 1, 1);
> unsigned short doy = static_cast<unsigned short>((*this-start_of_year).days() + 1);
> return day_of_year_type(doy);
> }
>
> date_int_type modjulian_day() const
> {
> ymd_type ymd = year_month_day();
> return gregorian_calendar::modjulian_day_number(ymd);
> }
>
> int week_number() const
> {
> ymd_type ymd = year_month_day();
> return gregorian_calendar::week_number(ymd);
> }
>
> date_int_type day_number() const
> {
> return days_;
> }
>
> date end_of_month() const
> {
> ymd_type ymd = year_month_day();
> short eom_day = gregorian_calendar::end_of_month_day(ymd.year, ymd.month);
> return date(ymd.year, ymd.month, eom_day);
> }
>
> private:
>
> };
>
>
>
>} }
># 13 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 2 3 4
>
># 1 "/usr/include/boost/date_time/adjust_functors.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/adjust_functors.hpp" 3 4
># 1 "/usr/include/boost/date_time/wrapping_int.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/wrapping_int.hpp" 3 4
>namespace boost {
>namespace date_time {
># 30 "/usr/include/boost/date_time/wrapping_int.hpp" 3 4
>template<typename int_type_, int_type_ wrap_val>
>class wrapping_int {
>public:
> typedef int_type_ int_type;
>
> static int_type wrap_value() {return wrap_val;}
>
> wrapping_int(int_type v) : value_(v) {}
>
> int_type as_int() const {return value_;}
> operator int_type() const {return value_;}
>
>
>
>
>
> template< typename IntT >
> IntT add(IntT v)
> {
> int_type remainder = static_cast<int_type>(v % (wrap_val));
> IntT overflow = static_cast<IntT>(v / (wrap_val));
> value_ = static_cast<int_type>(value_ + remainder);
> return calculate_wrap(overflow);
> }
>
>
>
>
>
>
> template< typename IntT >
> IntT subtract(IntT v)
> {
> int_type remainder = static_cast<int_type>(v % (wrap_val));
> IntT underflow = static_cast<IntT>(-(v / (wrap_val)));
> value_ = static_cast<int_type>(value_ - remainder);
> return calculate_wrap(underflow) * -1;
> }
>private:
> int_type value_;
>
> template< typename IntT >
> IntT calculate_wrap(IntT wrap)
> {
> if ((value_) >= wrap_val)
> {
> ++wrap;
> value_ -= (wrap_val);
> }
> else if(value_ < 0)
> {
> --wrap;
> value_ += (wrap_val);
> }
> return wrap;
> }
>
>};
>
>
>
>
>
>
>template<typename int_type_, int_type_ wrap_min, int_type_ wrap_max>
>class wrapping_int2 {
>public:
> typedef int_type_ int_type;
> static int_type wrap_value() {return wrap_max;}
> static int_type min_value() {return wrap_min;}
>
>
> wrapping_int2(int_type v) : value_(v) {
> if(value_ < wrap_min)
> {
> value_ = wrap_min;
> }
> if(value_ > wrap_max)
> {
> value_ = wrap_max;
> }
> }
>
> int_type as_int() const {return value_;}
> operator int_type() const {return value_;}
>
>
>
>
>
> template< typename IntT >
> IntT add(IntT v)
> {
> int_type remainder = static_cast<int_type>(v % (wrap_max - wrap_min + 1));
> IntT overflow = static_cast<IntT>(v / (wrap_max - wrap_min + 1));
> value_ = static_cast<int_type>(value_ + remainder);
> return calculate_wrap(overflow);
> }
>
>
>
>
>
> template< typename IntT >
> IntT subtract(IntT v)
> {
> int_type remainder = static_cast<int_type>(v % (wrap_max - wrap_min + 1));
> IntT underflow = static_cast<IntT>(-(v / (wrap_max - wrap_min + 1)));
> value_ = static_cast<int_type>(value_ - remainder);
> return calculate_wrap(underflow);
> }
>
>private:
> int_type value_;
>
> template< typename IntT >
> IntT calculate_wrap(IntT wrap)
> {
> if ((value_) > wrap_max)
> {
> ++wrap;
> value_ -= (wrap_max - wrap_min + 1);
> }
> else if((value_) < wrap_min)
> {
> --wrap;
> value_ += (wrap_max - wrap_min + 1);
> }
> return wrap;
> }
>};
>
>
>
>} }
># 14 "/usr/include/boost/date_time/adjust_functors.hpp" 2 3 4
>
>namespace boost {
>namespace date_time {
>
>
>
> template<class date_type>
> class day_functor
> {
> public:
> typedef typename date_type::duration_type duration_type;
> day_functor(int f) : f_(f) {}
> duration_type get_offset(const date_type& d) const
> {
>
>
> d.year();
> return duration_type(f_);
> }
> duration_type get_neg_offset(const date_type& d) const
> {
>
> d.year();
> return duration_type(-f_);
> }
> private:
> int f_;
> };
># 53 "/usr/include/boost/date_time/adjust_functors.hpp" 3 4
> template<class date_type>
> class month_functor
> {
> public:
> typedef typename date_type::duration_type duration_type;
> typedef typename date_type::calendar_type cal_type;
> typedef typename cal_type::ymd_type ymd_type;
> typedef typename cal_type::day_type day_type;
>
> month_functor(int f) : f_(f), origDayOfMonth_(0) {}
> duration_type get_offset(const date_type& d) const
> {
> ymd_type ymd(d.year_month_day());
> if (origDayOfMonth_ == 0) {
> origDayOfMonth_ = ymd.day;
> day_type endOfMonthDay(cal_type::end_of_month_day(ymd.year,ymd.month));
> if (endOfMonthDay == ymd.day) {
> origDayOfMonth_ = -1;
> }
> }
> typedef date_time::wrapping_int2<short,1,12> wrap_int2;
> typedef typename wrap_int2::int_type int_type;
> wrap_int2 wi(ymd.month);
>
> int_type year = wi.add(static_cast<int_type>(f_));
> year = static_cast<int_type>(year + ymd.year);
>
>
>
> day_type resultingEndOfMonthDay(cal_type::end_of_month_day(year, wi.as_int()));
>
> if (origDayOfMonth_ == -1) {
> return date_type(year, wi.as_int(), resultingEndOfMonthDay) - d;
> }
> day_type dayOfMonth = origDayOfMonth_;
> if (dayOfMonth > resultingEndOfMonthDay) {
> dayOfMonth = resultingEndOfMonthDay;
> }
> return date_type(year, wi.as_int(), dayOfMonth) - d;
> }
>
> duration_type get_neg_offset(const date_type& d) const
> {
> ymd_type ymd(d.year_month_day());
> if (origDayOfMonth_ == 0) {
> origDayOfMonth_ = ymd.day;
> day_type endOfMonthDay(cal_type::end_of_month_day(ymd.year,ymd.month));
> if (endOfMonthDay == ymd.day) {
> origDayOfMonth_ = -1;
> }
> }
> typedef date_time::wrapping_int2<short,1,12> wrap_int2;
> typedef typename wrap_int2::int_type int_type;
> wrap_int2 wi(ymd.month);
>
> int_type year = wi.subtract(static_cast<int_type>(f_));
> year = static_cast<int_type>(year + ymd.year);
>
> day_type resultingEndOfMonthDay(cal_type::end_of_month_day(year, wi.as_int()));
>
> if (origDayOfMonth_ == -1) {
> return date_type(year, wi.as_int(), resultingEndOfMonthDay) - d;
> }
> day_type dayOfMonth = origDayOfMonth_;
> if (dayOfMonth > resultingEndOfMonthDay) {
> dayOfMonth = resultingEndOfMonthDay;
> }
> return date_type(year, wi.as_int(), dayOfMonth) - d;
> }
> private:
> int f_;
> mutable short origDayOfMonth_;
> };
>
>
>
> template<class date_type>
> class week_functor
> {
> public:
> typedef typename date_type::duration_type duration_type;
> typedef typename date_type::calendar_type calendar_type;
> week_functor(int f) : f_(f) {}
> duration_type get_offset(const date_type& d) const
> {
>
>
> d.year();
> return duration_type(f_*calendar_type::days_in_week());
> }
> duration_type get_neg_offset(const date_type& d) const
> {
>
> d.year();
> return duration_type(-f_*calendar_type::days_in_week());
> }
> private:
> int f_;
> };
>
>
> template<class date_type>
> class year_functor
> {
> public:
>
> typedef typename date_type::duration_type duration_type;
> year_functor(int f) : _mf(f * 12) {}
> duration_type get_offset(const date_type& d) const
> {
> return _mf.get_offset(d);
> }
> duration_type get_neg_offset(const date_type& d) const
> {
> return _mf.get_neg_offset(d);
> }
> private:
> month_functor<date_type> _mf;
> };
>
>
>} }
># 15 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 2 3 4
>
>
>
>namespace boost {
>namespace gregorian {
>
>
> struct greg_durations_config {
> typedef date date_type;
> typedef date_time::int_adapter<int> int_rep;
> typedef date_time::month_functor<date_type> month_adjustor_type;
> };
>
> typedef date_time::months_duration<greg_durations_config> months;
> typedef date_time::years_duration<greg_durations_config> years;
>
> class weeks_duration : public date_duration {
> public:
> weeks_duration(duration_rep w)
> : date_duration(w * 7) {}
> weeks_duration(date_time::special_values sv)
> : date_duration(sv) {}
> };
>
> typedef weeks_duration weeks;
>
>}}
># 23 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/date_time/date_generators.hpp" 1 3 4
># 22 "/usr/include/boost/date_time/date_generators.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
>
>
>
>
>
> template<class date_type>
> class year_based_generator
> {
> public:
> typedef typename date_type::calendar_type calendar_type;
> typedef typename calendar_type::year_type year_type;
> year_based_generator() {}
> virtual ~year_based_generator() {}
> virtual date_type get_date(year_type y) const = 0;
>
> virtual std::string to_string() const =0;
> };
># 55 "/usr/include/boost/date_time/date_generators.hpp" 3 4
> template<class date_type>
> class partial_date : public year_based_generator<date_type>
> {
> public:
> typedef typename date_type::calendar_type calendar_type;
> typedef typename calendar_type::day_type day_type;
> typedef typename calendar_type::month_type month_type;
> typedef typename calendar_type::year_type year_type;
> typedef typename date_type::duration_type duration_type;
> typedef typename duration_type::duration_rep duration_rep;
> partial_date(day_type d, month_type m) :
> day_(d),
> month_(m)
> {}
>
>
>
>
>
> partial_date(duration_rep days) :
> day_(1),
> month_(1)
> {
> date_type d1(2000,1,1);
> if(days > 1) {
> if(days > 366)
> {
> days = 366;
> }
> days = days - 1;
> duration_type dd(days);
> d1 = d1 + dd;
> }
> day_ = d1.day();
> month_ = d1.month();
> }
># 101 "/usr/include/boost/date_time/date_generators.hpp" 3 4
> date_type get_date(year_type y) const
> {
> if((day_ == 29) && (month_ == 2) && !(calendar_type::is_leap_year(y))) {
> std::ostringstream ss;
> ss << "No Feb 29th in given year of " << y << ".";
> boost::throw_exception(std::invalid_argument(ss.str()));
> }
> return date_type(y, month_, day_);
> }
> date_type operator()(year_type y) const
> {
> return get_date(y);
>
> }
> bool operator==(const partial_date& rhs) const
> {
> return (month_ == rhs.month_) && (day_ == rhs.day_);
> }
> bool operator<(const partial_date& rhs) const
> {
> if (month_ < rhs.month_) return true;
> if (month_ > rhs.month_) return false;
>
> return (day_ < rhs.day_);
> }
>
>
> month_type month() const
> {
> return month_;
> }
> day_type day() const
> {
> return day_;
> }
>
>
>
>
>
>
> virtual std::string to_string() const
> {
> std::ostringstream ss;
> date_type d(2004, month_, day_);
> unsigned short c = d.day_of_year();
> c--;
> ss << c;
> return ss.str();
> }
> private:
> day_type day_;
> month_type month_;
> };
>
>
>
> const char* nth_as_str(int n);
># 177 "/usr/include/boost/date_time/date_generators.hpp" 3 4
> template<class date_type>
> class nth_kday_of_month : public year_based_generator<date_type>
> {
> public:
> typedef typename date_type::calendar_type calendar_type;
> typedef typename calendar_type::day_of_week_type day_of_week_type;
> typedef typename calendar_type::month_type month_type;
> typedef typename calendar_type::year_type year_type;
> typedef typename date_type::duration_type duration_type;
> enum week_num {first=1, second, third, fourth, fifth};
> nth_kday_of_month(week_num week_no,
> day_of_week_type dow,
> month_type m) :
> month_(m),
> wn_(week_no),
> dow_(dow)
> {}
>
> date_type get_date(year_type y) const
> {
> date_type d(y, month_, 1);
> duration_type one_day(1);
> duration_type one_week(7);
> while (dow_ != d.day_of_week()) {
> d = d + one_day;
> }
> int week = 1;
> while (week < wn_) {
> d = d + one_week;
> week++;
> }
>
> if(d.month() != month_) {
> d = d - one_week;
> }
> return d;
> }
>
> month_type month() const
> {
> return month_;
> }
> week_num nth_week() const
> {
> return wn_;
> }
> day_of_week_type day_of_week() const
> {
> return dow_;
> }
> const char* nth_week_as_str() const
> {
> return nth_as_str(wn_);
> }
>
>
> virtual std::string to_string() const
> {
> std::ostringstream ss;
> ss << 'M'
> << static_cast<int>(month_) << '.'
> << static_cast<int>(wn_) << '.'
> << static_cast<int>(dow_);
> return ss.str();
> }
> private:
> month_type month_;
> week_num wn_;
> day_of_week_type dow_;
> };
>
>
>
>
>
> template<class date_type>
> class first_kday_of_month : public year_based_generator<date_type>
> {
> public:
> typedef typename date_type::calendar_type calendar_type;
> typedef typename calendar_type::day_of_week_type day_of_week_type;
> typedef typename calendar_type::month_type month_type;
> typedef typename calendar_type::year_type year_type;
> typedef typename date_type::duration_type duration_type;
>
>
>
>
> first_kday_of_month(day_of_week_type dow, month_type m) :
> month_(m),
> dow_(dow)
> {}
>
> date_type get_date(year_type year) const
> {
> date_type d(year, month_,1);
> duration_type one_day(1);
> while (dow_ != d.day_of_week()) {
> d = d + one_day;
> }
> return d;
> }
>
> month_type month() const
> {
> return month_;
> }
> day_of_week_type day_of_week() const
> {
> return dow_;
> }
>
>
> virtual std::string to_string() const
> {
> std::ostringstream ss;
> ss << 'M'
> << static_cast<int>(month_) << '.'
> << 1 << '.'
> << static_cast<int>(dow_);
> return ss.str();
> }
> private:
> month_type month_;
> day_of_week_type dow_;
> };
># 313 "/usr/include/boost/date_time/date_generators.hpp" 3 4
> template<class date_type>
> class last_kday_of_month : public year_based_generator<date_type>
> {
> public:
> typedef typename date_type::calendar_type calendar_type;
> typedef typename calendar_type::day_of_week_type day_of_week_type;
> typedef typename calendar_type::month_type month_type;
> typedef typename calendar_type::year_type year_type;
> typedef typename date_type::duration_type duration_type;
>
>
>
>
> last_kday_of_month(day_of_week_type dow, month_type m) :
> month_(m),
> dow_(dow)
> {}
>
> date_type get_date(year_type year) const
> {
> date_type d(year, month_, calendar_type::end_of_month_day(year,month_));
> duration_type one_day(1);
> while (dow_ != d.day_of_week()) {
> d = d - one_day;
> }
> return d;
> }
>
> month_type month() const
> {
> return month_;
> }
> day_of_week_type day_of_week() const
> {
> return dow_;
> }
>
>
> virtual std::string to_string() const
> {
> std::ostringstream ss;
> ss << 'M'
> << static_cast<int>(month_) << '.'
> << 5 << '.'
> << static_cast<int>(dow_);
> return ss.str();
> }
> private:
> month_type month_;
> day_of_week_type dow_;
> };
># 375 "/usr/include/boost/date_time/date_generators.hpp" 3 4
> template<class date_type>
> class first_kday_after
> {
> public:
> typedef typename date_type::calendar_type calendar_type;
> typedef typename calendar_type::day_of_week_type day_of_week_type;
> typedef typename date_type::duration_type duration_type;
> first_kday_after(day_of_week_type dow) :
> dow_(dow)
> {}
>
> date_type get_date(date_type start_day) const
> {
> duration_type one_day(1);
> date_type d = start_day + one_day;
> while (dow_ != d.day_of_week()) {
> d = d + one_day;
> }
> return d;
> }
>
> day_of_week_type day_of_week() const
> {
> return dow_;
> }
> private:
> day_of_week_type dow_;
> };
># 413 "/usr/include/boost/date_time/date_generators.hpp" 3 4
> template<class date_type>
> class first_kday_before
> {
> public:
> typedef typename date_type::calendar_type calendar_type;
> typedef typename calendar_type::day_of_week_type day_of_week_type;
> typedef typename date_type::duration_type duration_type;
> first_kday_before(day_of_week_type dow) :
> dow_(dow)
> {}
>
> date_type get_date(date_type start_day) const
> {
> duration_type one_day(1);
> date_type d = start_day - one_day;
> while (dow_ != d.day_of_week()) {
> d = d - one_day;
> }
> return d;
> }
>
> day_of_week_type day_of_week() const
> {
> return dow_;
> }
> private:
> day_of_week_type dow_;
> };
>
>
>
>
>
> template<typename date_type, class weekday_type>
> inline
> typename date_type::duration_type days_until_weekday(const date_type& d, const weekday_type& wd)
> {
> typedef typename date_type::duration_type duration_type;
> duration_type wks(0);
> duration_type dd(wd.as_number() - d.day_of_week().as_number());
> if(dd.is_negative()){
> wks = duration_type(7);
> }
> return dd + wks;
> }
>
>
>
>
>
>
> template<typename date_type, class weekday_type>
> inline
> typename date_type::duration_type days_before_weekday(const date_type& d, const weekday_type& wd)
> {
> typedef typename date_type::duration_type duration_type;
> duration_type wks(0);
> duration_type dd(wd.as_number() - d.day_of_week().as_number());
> if(dd.days() > 0){
> wks = duration_type(7);
> }
>
>
> return (-dd + wks);
> }
>
>
>
>
>
>
> template<class date_type, class weekday_type>
> inline
> date_type next_weekday(const date_type& d, const weekday_type& wd)
> {
> return d + days_until_weekday(d, wd);
> }
>
>
>
>
>
>
> template<class date_type, class weekday_type>
> inline
> date_type previous_weekday(const date_type& d, const weekday_type& wd)
> {
> return d - days_before_weekday(d, wd);
> }
>
>} }
># 26 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/date_clock_device.hpp" 1 3 4
># 15 "/usr/include/boost/date_time/date_clock_device.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
>
>
>
>
>
> template<class date_type>
> class day_clock
> {
> public:
> typedef typename date_type::ymd_type ymd_type;
>
> static date_type local_day()
> {
> return date_type(local_day_ymd());
> }
>
> static typename date_type::ymd_type local_day_ymd()
> {
> ::std::tm result;
> ::std::tm* curr = get_local_time(result);
> return ymd_type(curr->tm_year + 1900,
> curr->tm_mon + 1,
> curr->tm_mday);
> }
>
> static typename date_type::ymd_type universal_day_ymd()
> {
> ::std::tm result;
> ::std::tm* curr = get_universal_time(result);
> return ymd_type(curr->tm_year + 1900,
> curr->tm_mon + 1,
> curr->tm_mday);
> }
>
> static date_type universal_day()
> {
> return date_type(universal_day_ymd());
> }
>
> private:
> static ::std::tm* get_local_time(std::tm& result)
> {
> ::std::time_t t;
> ::std::time(&t);
> return c_time::localtime(&t, &result);
> }
> static ::std::tm* get_universal_time(std::tm& result)
> {
> ::std::time_t t;
> ::std::time(&t);
> return c_time::gmtime(&t, &result);
> }
>
> };
>
>} }
># 27 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/date_iterator.hpp" 1 3 4
># 14 "/usr/include/boost/date_time/date_iterator.hpp" 3 4
>namespace boost {
>namespace date_time {
>
> enum date_resolutions {day, week, months, year, decade, century, NumDateResolutions};
># 32 "/usr/include/boost/date_time/date_iterator.hpp" 3 4
> template<class date_type>
> class date_itr_base {
>
>
>
> public:
> typedef typename date_type::duration_type duration_type;
> typedef date_type value_type;
> typedef std::input_iterator_tag iterator_category;
>
> date_itr_base(date_type d) : current_(d) {}
> virtual ~date_itr_base() {}
> date_itr_base& operator++()
> {
> current_ = current_ + get_offset(current_);
> return *this;
> }
> date_itr_base& operator--()
> {
> current_ = current_ + get_neg_offset(current_);
> return *this;
> }
> virtual duration_type get_offset(const date_type& current) const=0;
> virtual duration_type get_neg_offset(const date_type& current) const=0;
> date_type operator*() {return current_;}
> date_type* operator->() {return &current_;}
> bool operator< (const date_type& d) {return current_ < d;}
> bool operator<= (const date_type& d) {return current_ <= d;}
> bool operator> (const date_type& d) {return current_ > d;}
> bool operator>= (const date_type& d) {return current_ >= d;}
> bool operator== (const date_type& d) {return current_ == d;}
> bool operator!= (const date_type& d) {return current_ != d;}
> private:
> date_type current_;
> };
># 76 "/usr/include/boost/date_time/date_iterator.hpp" 3 4
> template<class offset_functor, class date_type>
> class date_itr : public date_itr_base<date_type> {
> public:
> typedef typename date_type::duration_type duration_type;
> date_itr(date_type d, int factor=1) :
> date_itr_base<date_type>(d),
> of_(factor)
> {}
> private:
> virtual duration_type get_offset(const date_type& current) const
> {
> return of_.get_offset(current);
> }
> virtual duration_type get_neg_offset(const date_type& current) const
> {
> return of_.get_neg_offset(current);
> }
> offset_functor of_;
> };
>
>
>
>} }
># 28 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
>
>
>namespace boost {
>
>
>
>
>
>
>namespace gregorian {
>
>
>
> typedef date_time::period<date, date_duration> date_period;
>
>
>
>
>
>
> typedef date_time::year_based_generator<date> year_based_generator;
>
>
> typedef date_time::partial_date<date> partial_date;
>
> typedef date_time::nth_kday_of_month<date> nth_kday_of_month;
> typedef nth_kday_of_month nth_day_of_the_week_in_month;
>
> typedef date_time::first_kday_of_month<date> first_kday_of_month;
> typedef first_kday_of_month first_day_of_the_week_in_month;
>
> typedef date_time::last_kday_of_month<date> last_kday_of_month;
> typedef last_kday_of_month last_day_of_the_week_in_month;
>
> typedef date_time::first_kday_after<date> first_kday_after;
> typedef first_kday_after first_day_of_the_week_after;
>
> typedef date_time::first_kday_before<date> first_kday_before;
> typedef first_kday_before first_day_of_the_week_before;
>
>
>
>
> typedef date_time::day_clock<date> day_clock;
>
>
>
>
> typedef date_time::date_itr_base<date> date_iterator;
>
>
>
>
> typedef date_time::date_itr<date_time::day_functor<date>,
> date> day_iterator;
>
>
>
> typedef date_time::date_itr<date_time::week_functor<date>,
> date> week_iterator;
>
>
>
> typedef date_time::date_itr<date_time::month_functor<date>,
> date> month_iterator;
>
>
>
> typedef date_time::date_itr<date_time::year_functor<date>,
> date> year_iterator;
>
>
> using date_time::days_until_weekday;
> using date_time::days_before_weekday;
> using date_time::next_weekday;
> using date_time::previous_weekday;
>
>} }
># 19 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
>
>
>
>namespace boost {
>namespace posix_time {
># 40 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
> typedef date_time::time_resolution_traits<
> boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::micro,
> 1000000, 6 > time_res_traits;
># 57 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
> class time_duration :
> public date_time::time_duration<time_duration, time_res_traits>
> {
> public:
> typedef time_res_traits rep_type;
> typedef time_res_traits::day_type day_type;
> typedef time_res_traits::hour_type hour_type;
> typedef time_res_traits::min_type min_type;
> typedef time_res_traits::sec_type sec_type;
> typedef time_res_traits::fractional_seconds_type fractional_seconds_type;
> typedef time_res_traits::tick_type tick_type;
> typedef time_res_traits::impl_type impl_type;
> time_duration(hour_type hour,
> min_type min,
> sec_type sec,
> fractional_seconds_type fs=0) :
> date_time::time_duration<time_duration, time_res_traits>(hour,min,sec,fs)
> {}
> time_duration() :
> date_time::time_duration<time_duration, time_res_traits>(0,0,0)
> {}
>
> time_duration(boost::date_time::special_values sv) :
> date_time::time_duration<time_duration, time_res_traits>(sv)
> {}
>
> friend class date_time::time_duration<time_duration, time_res_traits>;
> protected:
> explicit time_duration(impl_type tick_count) :
> date_time::time_duration<time_duration, time_res_traits>(tick_count)
> {}
> };
># 154 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
> class millisec_posix_time_system_config
> {
> public:
> typedef boost::int64_t time_rep_type;
>
> typedef gregorian::date date_type;
> typedef gregorian::date_duration date_duration_type;
> typedef time_duration time_duration_type;
> typedef time_res_traits::tick_type int_type;
> typedef time_res_traits::impl_type impl_type;
> typedef time_res_traits resolution_traits;
>
>
> static const boost::int64_t tick_per_second = 1000000;
>
> };
>
>
>
>} }
># 14 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/time_system_split.hpp" 1 3 4
># 17 "/usr/include/boost/date_time/time_system_split.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
>
>
>
> template<typename config>
>
> class split_timedate_system
> {
> public:
> typedef typename config::time_rep_type time_rep_type;
> typedef typename config::date_type date_type;
> typedef typename config::time_duration_type time_duration_type;
> typedef typename config::date_duration_type date_duration_type;
> typedef typename config::int_type int_type;
> typedef typename config::resolution_traits resolution_traits;
>
>
>
>
>
> private:
> static const int_type ticks_per_day = 86400L * config::tick_per_second;
> public:
>
>
>
> typedef date_time::wrapping_int<int_type, ticks_per_day> wrap_int_type;
>
>
>
> static time_rep_type get_time_rep(special_values sv)
> {
> switch (sv) {
> case not_a_date_time:
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
> case pos_infin:
> return time_rep_type(date_type(pos_infin),
> time_duration_type(pos_infin));
> case neg_infin:
> return time_rep_type(date_type(neg_infin),
> time_duration_type(neg_infin));
> case max_date_time: {
> time_duration_type td = time_duration_type(24,0,0,0) - time_duration_type(0,0,0,1);
> return time_rep_type(date_type(max_date_time), td);
> }
> case min_date_time:
> return time_rep_type(date_type(min_date_time), time_duration_type(0,0,0,0));
>
> default:
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
>
> }
>
> }
>
> static time_rep_type get_time_rep(const date_type& day,
> const time_duration_type& tod,
> date_time::dst_flags = not_dst)
> {
> if(day.is_special() || tod.is_special()) {
> if(day.is_not_a_date() || tod.is_not_a_date_time()) {
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
> }
> else if(day.is_pos_infinity()) {
> if(tod.is_neg_infinity()) {
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
> }
> else {
> return time_rep_type(day, time_duration_type(pos_infin));
> }
> }
> else if(day.is_neg_infinity()) {
> if(tod.is_pos_infinity()) {
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
> }
> else {
> return time_rep_type(day, time_duration_type(neg_infin));
> }
> }
> else if(tod.is_pos_infinity()) {
> if(day.is_neg_infinity()) {
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
> }
> else {
> return time_rep_type(date_type(pos_infin), tod);
> }
> }
> else if(tod.is_neg_infinity()) {
> if(day.is_pos_infinity()) {
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
> }
> else {
> return time_rep_type(date_type(neg_infin), tod);
> }
> }
> }
> return time_rep_type(day, tod);
> }
> static date_type get_date(const time_rep_type& val)
> {
> return date_type(val.day);
> }
> static time_duration_type get_time_of_day(const time_rep_type& val)
> {
> return time_duration_type(val.time_of_day);
> }
> static std::string zone_name(const time_rep_type&)
> {
> return std::string();
> }
> static bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
> {
> return ((lhs.day == rhs.day) && (lhs.time_of_day == rhs.time_of_day));
> }
> static bool is_less(const time_rep_type& lhs, const time_rep_type& rhs)
> {
> if (lhs.day < rhs.day) return true;
> if (lhs.day > rhs.day) return false;
> return (lhs.time_of_day < rhs.time_of_day);
> }
> static time_rep_type add_days(const time_rep_type& base,
> const date_duration_type& dd)
> {
> return time_rep_type(base.day+dd, base.time_of_day);
> }
> static time_rep_type subtract_days(const time_rep_type& base,
> const date_duration_type& dd)
> {
> return split_timedate_system::get_time_rep(base.day-dd, base.time_of_day);
> }
> static time_rep_type subtract_time_duration(const time_rep_type& base,
> const time_duration_type& td)
> {
> if(base.day.is_special() || td.is_special())
> {
> return split_timedate_system::get_time_rep(base.day, -td);
> }
> if (td.is_negative()) {
> time_duration_type td1 = td.invert_sign();
> return add_time_duration(base,td1);
> }
>
> wrap_int_type day_offset(base.time_of_day.ticks());
> date_duration_type day_overflow(static_cast<typename date_duration_type::duration_rep_type>(day_offset.subtract(td.ticks())));
>
> return time_rep_type(base.day-day_overflow,
> time_duration_type(0,0,0,day_offset.as_int()));
> }
> static time_rep_type add_time_duration(const time_rep_type& base,
> time_duration_type td)
> {
> if(base.day.is_special() || td.is_special()) {
> return split_timedate_system::get_time_rep(base.day, td);
> }
> if (td.is_negative()) {
> time_duration_type td1 = td.invert_sign();
> return subtract_time_duration(base,td1);
> }
>
> wrap_int_type day_offset(base.time_of_day.ticks());
> date_duration_type day_overflow(static_cast< typename date_duration_type::duration_rep_type >(day_offset.add(td.ticks())));
>
> return time_rep_type(base.day+day_overflow,
> time_duration_type(0,0,0,day_offset.as_int()));
> }
> static time_duration_type subtract_times(const time_rep_type& lhs,
> const time_rep_type& rhs)
> {
> date_duration_type dd = lhs.day - rhs.day;
> time_duration_type td(dd.days()*24,0,0);
> time_duration_type td2 = lhs.time_of_day - rhs.time_of_day;
> return td+td2;
>
> }
>
> };
>
>} }
># 15 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/time_system_counted.hpp" 1 3 4
># 18 "/usr/include/boost/date_time/time_system_counted.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
> template<class config>
> struct counted_time_rep
> {
> typedef typename config::int_type int_type;
> typedef typename config::date_type date_type;
> typedef typename config::impl_type impl_type;
> typedef typename date_type::duration_type date_duration_type;
> typedef typename date_type::calendar_type calendar_type;
> typedef typename date_type::ymd_type ymd_type;
> typedef typename config::time_duration_type time_duration_type;
> typedef typename config::resolution_traits resolution_traits;
>
> counted_time_rep(const date_type& d, const time_duration_type& time_of_day)
> : time_count_(1)
> {
> if(d.is_infinity() || d.is_not_a_date() || time_of_day.is_special()) {
> time_count_ = time_of_day.get_rep() + d.day_count();
>
> }
> else {
> time_count_ = (d.day_number() * frac_sec_per_day()) + time_of_day.ticks();
> }
> }
> explicit counted_time_rep(int_type count) :
> time_count_(count)
> {}
> explicit counted_time_rep(impl_type count) :
> time_count_(count)
> {}
> date_type date() const
> {
> if(time_count_.is_special()) {
> return date_type(time_count_.as_special());
> }
> else {
> typename calendar_type::date_int_type dc = day_count();
>
> ymd_type ymd = calendar_type::from_day_number(dc);
> return date_type(ymd);
> }
> }
>
> unsigned long day_count() const
> {
># 78 "/usr/include/boost/date_time/time_system_counted.hpp" 3 4
> return static_cast<unsigned long>(resolution_traits::as_number(time_count_) / frac_sec_per_day());
> }
> int_type time_count() const
> {
> return resolution_traits::as_number(time_count_);
> }
> int_type tod() const
> {
> return resolution_traits::as_number(time_count_) % frac_sec_per_day();
> }
> static int_type frac_sec_per_day()
> {
> int_type seconds_per_day = 60*60*24;
> int_type fractional_sec_per_sec(resolution_traits::res_adjust());
> return seconds_per_day*fractional_sec_per_sec;
> }
> bool is_pos_infinity()const
> {
> return impl_type::is_pos_inf(time_count_.as_number());
> }
> bool is_neg_infinity()const
> {
> return impl_type::is_neg_inf(time_count_.as_number());
> }
> bool is_not_a_date_time()const
> {
> return impl_type::is_not_a_number(time_count_.as_number());
> }
> bool is_special()const
> {
> return time_count_.is_special();
> }
> impl_type get_rep()const
> {
> return time_count_;
> }
> private:
> impl_type time_count_;
> };
>
>
> template<class time_rep>
> class counted_time_system
> {
> public:
> typedef time_rep time_rep_type;
> typedef typename time_rep_type::impl_type impl_type;
> typedef typename time_rep_type::time_duration_type time_duration_type;
> typedef typename time_duration_type::fractional_seconds_type fractional_seconds_type;
> typedef typename time_rep_type::date_type date_type;
> typedef typename time_rep_type::date_duration_type date_duration_type;
>
>
> template<class T> static void unused_var(const T&) {}
>
> static time_rep_type get_time_rep(const date_type& day,
> const time_duration_type& tod,
> date_time::dst_flags dst=not_dst)
> {
> unused_var(dst);
> return time_rep_type(day, tod);
> }
>
> static time_rep_type get_time_rep(special_values sv)
> {
> switch (sv) {
> case not_a_date_time:
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
> case pos_infin:
> return time_rep_type(date_type(pos_infin),
> time_duration_type(pos_infin));
> case neg_infin:
> return time_rep_type(date_type(neg_infin),
> time_duration_type(neg_infin));
> case max_date_time: {
> time_duration_type td = time_duration_type(24,0,0,0) - time_duration_type(0,0,0,1);
> return time_rep_type(date_type(max_date_time), td);
> }
> case min_date_time:
> return time_rep_type(date_type(min_date_time), time_duration_type(0,0,0,0));
>
> default:
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
>
> }
>
> }
>
> static date_type get_date(const time_rep_type& val)
> {
> return val.date();
> }
> static time_duration_type get_time_of_day(const time_rep_type& val)
> {
> if(val.is_special()) {
> return time_duration_type(val.get_rep().as_special());
> }
> else{
> return time_duration_type(0,0,0,val.tod());
> }
> }
> static std::string zone_name(const time_rep_type&)
> {
> return "";
> }
> static bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
> {
> return (lhs.time_count() == rhs.time_count());
> }
> static bool is_less(const time_rep_type& lhs, const time_rep_type& rhs)
> {
> return (lhs.time_count() < rhs.time_count());
> }
> static time_rep_type add_days(const time_rep_type& base,
> const date_duration_type& dd)
> {
> if(base.is_special() || dd.is_special()) {
> return(time_rep_type(base.get_rep() + dd.get_rep()));
> }
> else {
> return time_rep_type(base.time_count() + (dd.days() * time_rep_type::frac_sec_per_day()));
> }
> }
> static time_rep_type subtract_days(const time_rep_type& base,
> const date_duration_type& dd)
> {
> if(base.is_special() || dd.is_special()) {
> return(time_rep_type(base.get_rep() - dd.get_rep()));
> }
> else{
> return time_rep_type(base.time_count() - (dd.days() * time_rep_type::frac_sec_per_day()));
> }
> }
> static time_rep_type subtract_time_duration(const time_rep_type& base,
> const time_duration_type& td)
> {
> if(base.is_special() || td.is_special()) {
> return(time_rep_type(base.get_rep() - td.get_rep()));
> }
> else {
> return time_rep_type(base.time_count() - td.ticks());
> }
> }
> static time_rep_type add_time_duration(const time_rep_type& base,
> time_duration_type td)
> {
> if(base.is_special() || td.is_special()) {
> return(time_rep_type(base.get_rep() + td.get_rep()));
> }
> else {
> return time_rep_type(base.time_count() + td.ticks());
> }
> }
> static time_duration_type subtract_times(const time_rep_type& lhs,
> const time_rep_type& rhs)
> {
> if(lhs.is_special() || rhs.is_special()) {
> return(time_duration_type(
> impl_type::to_special((lhs.get_rep() - rhs.get_rep()).as_number())));
> }
> else {
> fractional_seconds_type fs = lhs.time_count() - rhs.time_count();
> return time_duration_type(0,0,0,fs);
> }
> }
>
> };
>
>
>} }
># 16 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 2 3 4
>
>
>
>namespace boost {
>namespace posix_time {
># 32 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 3 4
> typedef date_time::counted_time_rep<millisec_posix_time_system_config> int64_time_rep;
> typedef date_time::counted_time_system<int64_time_rep> posix_time_system;
>
>
>
>} }
># 13 "/usr/include/boost/date_time/posix_time/ptime.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/time.hpp" 1 3 4
># 21 "/usr/include/boost/date_time/time.hpp" 3 4
>namespace boost {
>namespace date_time {
># 45 "/usr/include/boost/date_time/time.hpp" 3 4
> template <class T, class time_system>
> class base_time : private
> boost::less_than_comparable<T
> , boost::equality_comparable<T
> > >
> {
> public:
> typedef T time_type;
> typedef typename time_system::time_rep_type time_rep_type;
> typedef typename time_system::date_type date_type;
> typedef typename time_system::date_duration_type date_duration_type;
> typedef typename time_system::time_duration_type time_duration_type;
>
>
> base_time(const date_type& day,
> const time_duration_type& td,
> dst_flags dst=not_dst) :
> time_(time_system::get_time_rep(day, td, dst))
> {}
> base_time(special_values sv) :
> time_(time_system::get_time_rep(sv))
> {}
> base_time(const time_rep_type& rhs) :
> time_(rhs)
> {}
> date_type date() const
> {
> return time_system::get_date(time_);
> }
> time_duration_type time_of_day() const
> {
> return time_system::get_time_of_day(time_);
> }
>
>
>
> std::string zone_name(bool =false) const
> {
> return time_system::zone_name(time_);
> }
>
>
>
> std::string zone_abbrev(bool =false) const
> {
> return time_system::zone_name(time_);
> }
>
> std::string zone_as_posix_string() const
> {
> return std::string();
> }
>
>
> bool is_not_a_date_time() const
> {
> return time_.is_not_a_date_time();
> }
>
> bool is_infinity() const
> {
> return (is_pos_infinity() || is_neg_infinity());
> }
>
> bool is_pos_infinity() const
> {
> return time_.is_pos_infinity();
> }
>
> bool is_neg_infinity() const
> {
> return time_.is_neg_infinity();
> }
>
> bool is_special() const
> {
> return(is_not_a_date_time() || is_infinity());
> }
>
> bool operator==(const time_type& rhs) const
> {
> return time_system::is_equal(time_,rhs.time_);
> }
>
> bool operator<(const time_type& rhs) const
> {
> return time_system::is_less(time_,rhs.time_);
> }
>
> time_duration_type operator-(const time_type& rhs) const
> {
> return time_system::subtract_times(time_, rhs.time_);
> }
>
> time_type operator+(const date_duration_type& dd) const
> {
> return time_system::add_days(time_, dd);
> }
> time_type operator+=(const date_duration_type& dd)
> {
> time_ = (time_system::get_time_rep(date() + dd, time_of_day()));
> return time_type(time_);
> }
>
> time_type operator-(const date_duration_type& dd) const
> {
> return time_system::subtract_days(time_, dd);
> }
> time_type operator-=(const date_duration_type& dd)
> {
> time_ = (time_system::get_time_rep(date() - dd, time_of_day()));
> return time_type(time_);
> }
>
> time_type operator+(const time_duration_type& td) const
> {
> return time_type(time_system::add_time_duration(time_, td));
> }
> time_type operator+=(const time_duration_type& td)
> {
> time_ = (time_system::get_time_rep(date(), time_of_day() + td));
> return time_type(time_);
> }
>
> time_type operator-(const time_duration_type& rhs) const
> {
> return time_system::subtract_time_duration(time_, rhs);
> }
> time_type operator-=(const time_duration_type& td)
> {
> time_ = (time_system::get_time_rep(date(), time_of_day() - td));
> return time_type(time_);
> }
>
> protected:
> time_rep_type time_;
> };
>
>
>
>
>
>} }
># 14 "/usr/include/boost/date_time/posix_time/ptime.hpp" 2 3 4
>
>namespace boost {
>
>namespace posix_time {
>
>
> using date_time::special_values;
> using date_time::not_special;
> using date_time::neg_infin;
> using date_time::pos_infin;
> using date_time::not_a_date_time;
> using date_time::max_date_time;
> using date_time::min_date_time;
>
>
>
>
> class ptime : public date_time::base_time<ptime, posix_time_system>
> {
> public:
> typedef posix_time_system time_system_type;
> typedef time_system_type::time_rep_type time_rep_type;
> typedef time_system_type::time_duration_type time_duration_type;
> typedef ptime time_type;
>
> ptime(gregorian::date d,time_duration_type td) : date_time::base_time<time_type,time_system_type>(d,td)
> {}
>
> explicit ptime(gregorian::date d) : date_time::base_time<time_type,time_system_type>(d,time_duration_type(0,0,0))
> {}
>
> ptime(const time_rep_type& rhs):
> date_time::base_time<time_type,time_system_type>(rhs)
> {}
>
> ptime(const special_values sv) : date_time::base_time<time_type,time_system_type>(sv)
> {}
>
>
> ptime() : date_time::base_time<time_type,time_system_type>(gregorian::date(not_a_date_time), time_duration_type(not_a_date_time))
> {}
>
>
> };
>
>
>
>} }
># 13 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
>
># 1 "/usr/include/boost/date_time/posix_time/date_duration_operators.hpp" 1 3 4
># 15 "/usr/include/boost/date_time/posix_time/date_duration_operators.hpp" 3 4
>namespace boost {
>namespace posix_time {
># 29 "/usr/include/boost/date_time/posix_time/date_duration_operators.hpp" 3 4
> inline
> ptime
> operator+(const ptime& t, const boost::gregorian::months& m)
> {
> return t + m.get_offset(t.date());
> }
>
>
>
>
> inline
> ptime
> operator+=(ptime& t, const boost::gregorian::months& m)
> {
>
> return t += m.get_offset(t.date());
> }
>
>
>
>
> inline
> ptime
> operator-(const ptime& t, const boost::gregorian::months& m)
> {
>
> return t + m.get_neg_offset(t.date());
> }
>
>
>
>
> inline
> ptime
> operator-=(ptime& t, const boost::gregorian::months& m)
> {
> return t += m.get_neg_offset(t.date());
> }
>
>
>
>
>
>
> inline
> ptime
> operator+(const ptime& t, const boost::gregorian::years& y)
> {
> return t + y.get_offset(t.date());
> }
>
>
>
>
> inline
> ptime
> operator+=(ptime& t, const boost::gregorian::years& y)
> {
> return t += y.get_offset(t.date());
> }
>
>
>
>
> inline
> ptime
> operator-(const ptime& t, const boost::gregorian::years& y)
> {
>
> return t + y.get_neg_offset(t.date());
> }
>
>
>
>
> inline
> ptime
> operator-=(ptime& t, const boost::gregorian::years& y)
> {
>
> return t += y.get_neg_offset(t.date());
> }
>
>}}
># 15 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
>
># 1 "/usr/include/boost/date_time/posix_time/posix_time_duration.hpp" 1 3 4
># 14 "/usr/include/boost/date_time/posix_time/posix_time_duration.hpp" 3 4
>namespace boost {
>namespace posix_time {
>
>
>
>
> class hours : public time_duration
> {
> public:
> explicit hours(long h) :
> time_duration(h,0,0)
> {}
> };
>
>
>
>
> class minutes : public time_duration
> {
> public:
> explicit minutes(long m) :
> time_duration(0,m,0)
> {}
> };
>
>
>
>
> class seconds : public time_duration
> {
> public:
> explicit seconds(long s) :
> time_duration(0,0,s)
> {}
> };
>
>
>
>
>
> typedef date_time::subsecond_duration<time_duration,1000> millisec;
> typedef date_time::subsecond_duration<time_duration,1000> milliseconds;
>
>
>
>
> typedef date_time::subsecond_duration<time_duration,1000000> microsec;
> typedef date_time::subsecond_duration<time_duration,1000000> microseconds;
># 78 "/usr/include/boost/date_time/posix_time/posix_time_duration.hpp" 3 4
>} }
># 17 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
>
># 1 "/usr/include/boost/date_time/posix_time/time_period.hpp" 1 3 4
># 16 "/usr/include/boost/date_time/posix_time/time_period.hpp" 3 4
>namespace boost {
>namespace posix_time {
>
>
>
>
> typedef date_time::period<ptime, time_duration> time_period;
>
>
>} }
># 19 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/time_iterator.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/time_iterator.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
>
> template<class time_type>
> class time_itr {
> public:
> typedef typename time_type::time_duration_type time_duration_type;
> time_itr(time_type t, time_duration_type d) : current_(t), offset_(d) {}
> time_itr& operator++()
> {
> current_ = current_ + offset_;
> return *this;
> }
> time_itr& operator--()
> {
> current_ = current_ - offset_;
> return *this;
> }
> time_type operator*() {return current_;}
> time_type* operator->() {return &current_;}
> bool operator< (const time_type& t) {return current_ < t;}
> bool operator<= (const time_type& t) {return current_ <= t;}
> bool operator!= (const time_type& t) {return current_ != t;}
> bool operator== (const time_type& t) {return current_ == t;}
> bool operator> (const time_type& t) {return current_ > t;}
> bool operator>= (const time_type& t) {return current_ >= t;}
>
> private:
> time_type current_;
> time_duration_type offset_;
> };
>
>
>
>} }
># 20 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/dst_rules.hpp" 1 3 4
># 21 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
>namespace boost {
> namespace date_time {
>
> enum time_is_dst_result {is_not_in_dst, is_in_dst,
> ambiguous, invalid_time_label};
>
>
>
> template<class date_type_,
> class time_duration_type_>
> class dst_calculator
> {
> public:
> typedef time_duration_type_ time_duration_type;
> typedef date_type_ date_type;
># 47 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
> static time_is_dst_result
> process_local_dst_start_day(const time_duration_type& time_of_day,
> unsigned int dst_start_offset_minutes,
> long dst_length_minutes)
> {
>
> if (time_of_day < time_duration_type(0,dst_start_offset_minutes,0)) {
> return is_not_in_dst;
> }
> long offset = dst_start_offset_minutes + dst_length_minutes;
> if (time_of_day >= time_duration_type(0,offset,0)) {
> return is_in_dst;
> }
> return invalid_time_label;
> }
># 72 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
> static time_is_dst_result
> process_local_dst_end_day(const time_duration_type& time_of_day,
> unsigned int dst_end_offset_minutes,
> long dst_length_minutes)
> {
>
> int offset = dst_end_offset_minutes-dst_length_minutes;
> if (time_of_day < time_duration_type(0,offset,0)) {
> return is_in_dst;
> }
> if (time_of_day >= time_duration_type(0,dst_end_offset_minutes,0)) {
> return is_not_in_dst;
> }
> return ambiguous;
> }
># 100 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
> static time_is_dst_result
> local_is_dst(const date_type& current_day,
> const time_duration_type& time_of_day,
> const date_type& dst_start_day,
> const time_duration_type& dst_start_offset,
> const date_type& dst_end_day,
> const time_duration_type& dst_end_offset,
> const time_duration_type& dst_length_minutes)
> {
> unsigned int start_minutes =
> dst_start_offset.hours() * 60 + dst_start_offset.minutes();
> unsigned int end_minutes =
> dst_end_offset.hours() * 60 + dst_end_offset.minutes();
> long length_minutes =
> dst_length_minutes.hours() * 60 + dst_length_minutes.minutes();
>
> return local_is_dst(current_day, time_of_day,
> dst_start_day, start_minutes,
> dst_end_day, end_minutes,
> length_minutes);
> }
># 136 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
> static time_is_dst_result
> local_is_dst(const date_type& current_day,
> const time_duration_type& time_of_day,
> const date_type& dst_start_day,
> unsigned int dst_start_offset_minutes,
> const date_type& dst_end_day,
> unsigned int dst_end_offset_minutes,
> long dst_length_minutes)
> {
>
> if (dst_start_day < dst_end_day) {
> if ((current_day > dst_start_day) && (current_day < dst_end_day)) {
> return is_in_dst;
> }
> if ((current_day < dst_start_day) || (current_day > dst_end_day)) {
> return is_not_in_dst;
> }
> }
> else {
> if ((current_day < dst_start_day) && (current_day > dst_end_day)) {
> return is_not_in_dst;
> }
> if ((current_day > dst_start_day) || (current_day < dst_end_day)) {
> return is_in_dst;
> }
> }
>
> if (current_day == dst_start_day) {
> return process_local_dst_start_day(time_of_day,
> dst_start_offset_minutes,
> dst_length_minutes);
> }
>
> if (current_day == dst_end_day) {
> return process_local_dst_end_day(time_of_day,
> dst_end_offset_minutes,
> dst_length_minutes);
> }
>
> return invalid_time_label;
> }
>
> };
># 208 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
> template<class date_type,
> class time_duration_type,
> class dst_traits>
> class dst_calc_engine
> {
> public:
> typedef typename date_type::year_type year_type;
> typedef typename date_type::calendar_type calendar_type;
> typedef dst_calculator<date_type, time_duration_type> dstcalc;
>
>
>
>
>
>
> static time_is_dst_result local_is_dst(const date_type& d,
> const time_duration_type& td)
> {
>
> year_type y = d.year();
> date_type dst_start = local_dst_start_day(y);
> date_type dst_end = local_dst_end_day(y);
> return dstcalc::local_is_dst(d,td,
> dst_start,
> dst_traits::dst_start_offset_minutes(),
> dst_end,
> dst_traits::dst_end_offset_minutes(),
> dst_traits::dst_shift_length_minutes());
>
> }
>
> static bool is_dst_boundary_day(date_type d)
> {
> year_type y = d.year();
> return ((d == local_dst_start_day(y)) ||
> (d == local_dst_end_day(y)));
> }
>
>
> static time_duration_type dst_offset()
> {
> return time_duration_type(0,dst_traits::dst_shift_length_minutes(),0);
> }
>
> static date_type local_dst_start_day(year_type year)
> {
> return dst_traits::local_dst_start_day(year);
> }
>
> static date_type local_dst_end_day(year_type year)
> {
> return dst_traits::local_dst_end_day(year);
> }
>
>
> };
>
>
>
>
>
>
> template<class date_type_,
> class time_duration_type_,
> unsigned int dst_start_offset_minutes=120,
> short dst_length_minutes=60>
> class us_dst_rules
> {
> public:
> typedef time_duration_type_ time_duration_type;
> typedef date_type_ date_type;
> typedef typename date_type::year_type year_type;
> typedef typename date_type::calendar_type calendar_type;
> typedef date_time::last_kday_of_month<date_type> lkday;
> typedef date_time::first_kday_of_month<date_type> fkday;
> typedef date_time::nth_kday_of_month<date_type> nkday;
> typedef dst_calculator<date_type, time_duration_type> dstcalc;
>
>
>
>
>
>
> static time_is_dst_result local_is_dst(const date_type& d,
> const time_duration_type& td)
> {
>
> year_type y = d.year();
> date_type dst_start = local_dst_start_day(y);
> date_type dst_end = local_dst_end_day(y);
> return dstcalc::local_is_dst(d,td,
> dst_start,dst_start_offset_minutes,
> dst_end, dst_start_offset_minutes,
> dst_length_minutes);
>
> }
>
>
> static bool is_dst_boundary_day(date_type d)
> {
> year_type y = d.year();
> return ((d == local_dst_start_day(y)) ||
> (d == local_dst_end_day(y)));
> }
>
> static date_type local_dst_start_day(year_type year)
> {
> if (year >= year_type(2007)) {
>
> nkday ssim(nkday::second, Sunday, gregorian::Mar);
> return ssim.get_date(year);
> } else {
>
> fkday fsia(Sunday, gregorian::Apr);
> return fsia.get_date(year);
> }
> }
>
> static date_type local_dst_end_day(year_type year)
> {
> if (year >= year_type(2007)) {
>
> fkday fsin(Sunday, gregorian::Nov);
> return fsin.get_date(year);
> } else {
>
> lkday lsio(Sunday, gregorian::Oct);
> return lsio.get_date(year);
> }
> }
>
> static time_duration_type dst_offset()
> {
> return time_duration_type(0,dst_length_minutes,0);
> }
>
> private:
>
>
> };
>
>
> template<class date_type_, class time_duration_type_>
> class null_dst_rules
> {
> public:
> typedef time_duration_type_ time_duration_type;
> typedef date_type_ date_type;
>
>
>
>
>
> static time_is_dst_result local_is_dst(const date_type&,
> const time_duration_type&)
> {
> return is_not_in_dst;
> }
>
>
> static time_is_dst_result utc_is_dst(const date_type&,
> const time_duration_type&)
> {
> return is_not_in_dst;
> }
>
> static bool is_dst_boundary_day(date_type )
> {
> return false;
> }
>
> static time_duration_type dst_offset()
> {
> return time_duration_type(0,0,0);
> }
>
> };
>
>
> } }
># 21 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
>
>namespace boost {
>
>
>namespace posix_time {
>
>
>
>
> typedef date_time::time_itr<ptime> time_iterator;
>
>
>
> typedef date_time::second_clock<ptime> second_clock;
>
>
>
>
>
> typedef date_time::microsec_clock<ptime> microsec_clock;
>
>
>
> typedef date_time::null_dst_rules<ptime::date_type, time_duration> no_dst;
>
> typedef date_time::us_dst_rules<ptime::date_type, time_duration> us_dst;
>
>
>} }
># 25 "/usr/include/boost/asio/time_traits.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/time_traits.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/time_traits.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>template <typename Time>
>struct time_traits;
>
>
>template <>
>struct time_traits<boost::posix_time::ptime>
>{
>
> typedef boost::posix_time::ptime time_type;
>
>
> typedef boost::posix_time::time_duration duration_type;
>
>
> static time_type now()
> {
>
> return boost::posix_time::microsec_clock::universal_time();
>
>
>
> }
>
>
> static time_type add(const time_type& t, const duration_type& d)
> {
> return t + d;
> }
>
>
> static duration_type subtract(const time_type& t1, const time_type& t2)
> {
> return t1 - t2;
> }
>
>
> static bool less_than(const time_type& t1, const time_type& t2)
> {
> return t1 < t2;
> }
>
>
> static boost::posix_time::time_duration to_posix_duration(
> const duration_type& d)
> {
> return d;
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 86 "/usr/include/boost/asio/time_traits.hpp" 2 3 4
># 28 "/usr/include/boost/asio/deadline_timer_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/timer_queue_ptime.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/timer_queue_ptime.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/timer_queue_ptime.hpp" 2 3 4
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>struct forwarding_posix_time_traits : time_traits<boost::posix_time::ptime> {};
>
>
>template <>
>class timer_queue<time_traits<boost::posix_time::ptime> >
> : public timer_queue_base
>{
>public:
>
> typedef boost::posix_time::ptime time_type;
>
>
> typedef boost::posix_time::time_duration duration_type;
>
>
> typedef timer_queue<forwarding_posix_time_traits>::per_timer_data
> per_timer_data;
>
>
> inline timer_queue();
>
>
> inline virtual ~timer_queue();
>
>
>
>
> inline bool enqueue_timer(const time_type& time,
> per_timer_data& timer, wait_op* op);
>
>
> inline virtual bool empty() const;
>
>
> inline virtual long wait_duration_msec(long max_duration) const;
>
>
> inline virtual long wait_duration_usec(long max_duration) const;
>
>
> inline virtual void get_ready_timers(op_queue<operation>& ops);
>
>
> inline virtual void get_all_timers(op_queue<operation>& ops);
>
>
> inline std::size_t cancel_timer(
> per_timer_data& timer, op_queue<operation>& ops,
> std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
>
>private:
> timer_queue<forwarding_posix_time_traits> impl_;
>};
>
>}
>}
>}
>
>
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 90 "/usr/include/boost/asio/detail/timer_queue_ptime.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/timer_queue_ptime.ipp" 1 3 4
># 19 "/usr/include/boost/asio/detail/impl/timer_queue_ptime.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/timer_queue_ptime.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/timer_queue_ptime.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/impl/timer_queue_ptime.ipp" 2 3 4
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>timer_queue<time_traits<boost::posix_time::ptime> >::timer_queue()
>{
>}
>
>timer_queue<time_traits<boost::posix_time::ptime> >::~timer_queue()
>{
>}
>
>bool timer_queue<time_traits<boost::posix_time::ptime> >::enqueue_timer(
> const time_type& time, per_timer_data& timer, wait_op* op)
>{
> return impl_.enqueue_timer(time, timer, op);
>}
>
>bool timer_queue<time_traits<boost::posix_time::ptime> >::empty() const
>{
> return impl_.empty();
>}
>
>long timer_queue<time_traits<boost::posix_time::ptime> >::wait_duration_msec(
> long max_duration) const
>{
> return impl_.wait_duration_msec(max_duration);
>}
>
>long timer_queue<time_traits<boost::posix_time::ptime> >::wait_duration_usec(
> long max_duration) const
>{
> return impl_.wait_duration_usec(max_duration);
>}
>
>void timer_queue<time_traits<boost::posix_time::ptime> >::get_ready_timers(
> op_queue<operation>& ops)
>{
> impl_.get_ready_timers(ops);
>}
>
>void timer_queue<time_traits<boost::posix_time::ptime> >::get_all_timers(
> op_queue<operation>& ops)
>{
> impl_.get_all_timers(ops);
>}
>
>std::size_t timer_queue<time_traits<boost::posix_time::ptime> >::cancel_timer(
> per_timer_data& timer, op_queue<operation>& ops, std::size_t max_cancelled)
>{
> return impl_.cancel_timer(timer, ops, max_cancelled);
>}
>
>}
>}
>}
>
>
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 85 "/usr/include/boost/asio/detail/impl/timer_queue_ptime.ipp" 2 3 4
># 93 "/usr/include/boost/asio/detail/timer_queue_ptime.hpp" 2 3 4
># 29 "/usr/include/boost/asio/deadline_timer_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 31 "/usr/include/boost/asio/deadline_timer_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>template <typename TimeType,
> typename TimeTraits = boost::asio::time_traits<TimeType> >
>class deadline_timer_service
>
>
>
> : public boost::asio::detail::service_base<
> deadline_timer_service<TimeType, TimeTraits> >
>
>{
>public:
>
>
>
>
>
>
> typedef TimeTraits traits_type;
>
>
> typedef typename traits_type::time_type time_type;
>
>
> typedef typename traits_type::duration_type duration_type;
>
>private:
>
> typedef detail::deadline_timer_service<traits_type> service_impl_type;
>
>public:
>
>
>
>
> typedef typename service_impl_type::implementation_type implementation_type;
>
>
>
> explicit deadline_timer_service(boost::asio::io_service& io_service)
> : boost::asio::detail::service_base<
> deadline_timer_service<TimeType, TimeTraits> >(io_service),
> service_impl_(io_service)
> {
> }
>
>
> void construct(implementation_type& impl)
> {
> service_impl_.construct(impl);
> }
>
>
> void destroy(implementation_type& impl)
> {
> service_impl_.destroy(impl);
> }
>
>
> std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
> {
> return service_impl_.cancel(impl, ec);
> }
>
>
> std::size_t cancel_one(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.cancel_one(impl, ec);
> }
>
>
> time_type expires_at(const implementation_type& impl) const
> {
> return service_impl_.expires_at(impl);
> }
>
>
> std::size_t expires_at(implementation_type& impl,
> const time_type& expiry_time, boost::system::error_code& ec)
> {
> return service_impl_.expires_at(impl, expiry_time, ec);
> }
>
>
> duration_type expires_from_now(const implementation_type& impl) const
> {
> return service_impl_.expires_from_now(impl);
> }
>
>
> std::size_t expires_from_now(implementation_type& impl,
> const duration_type& expiry_time, boost::system::error_code& ec)
> {
> return service_impl_.expires_from_now(impl, expiry_time, ec);
> }
>
>
> void wait(implementation_type& impl, boost::system::error_code& ec)
> {
> service_impl_.wait(impl, ec);
> }
>
>
> template <typename WaitHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
>
> async_wait(implementation_type& impl,
> WaitHandler&& handler)
> {
> detail::async_result_init<
> WaitHandler, void (boost::system::error_code)> init(
> static_cast<WaitHandler&&>(handler));
>
> service_impl_.async_wait(impl, init.handler);
>
> return init.result.get();
> }
>
>private:
>
> void shutdown_service()
> {
> service_impl_.shutdown_service();
> }
>
>
> service_impl_type service_impl_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 169 "/usr/include/boost/asio/deadline_timer_service.hpp" 2 3 4
># 26 "/usr/include/boost/asio/basic_deadline_timer.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 31 "/usr/include/boost/asio/basic_deadline_timer.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 123 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
>template <typename Time,
> typename TimeTraits = boost::asio::time_traits<Time>,
> typename TimerService = deadline_timer_service<Time, TimeTraits> >
>class basic_deadline_timer
> : public basic_io_object<TimerService>
>{
>public:
>
> typedef TimeTraits traits_type;
>
>
> typedef typename traits_type::time_type time_type;
>
>
> typedef typename traits_type::duration_type duration_type;
># 148 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> explicit basic_deadline_timer(boost::asio::io_service& io_service)
> : basic_io_object<TimerService>(io_service)
> {
> }
># 163 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> basic_deadline_timer(boost::asio::io_service& io_service,
> const time_type& expiry_time)
> : basic_io_object<TimerService>(io_service)
> {
> boost::system::error_code ec;
> this->service.expires_at(this->implementation, expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_at");
> }
># 182 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> basic_deadline_timer(boost::asio::io_service& io_service,
> const duration_type& expiry_time)
> : basic_io_object<TimerService>(io_service)
> {
> boost::system::error_code ec;
> this->service.expires_from_now(this->implementation, expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_from_now");
> }
># 213 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t cancel()
> {
> boost::system::error_code ec;
> std::size_t s = this->service.cancel(this->implementation, ec);
> boost::asio::detail::throw_error(ec, "cancel");
> return s;
> }
># 243 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t cancel(boost::system::error_code& ec)
> {
> return this->service.cancel(this->implementation, ec);
> }
># 272 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t cancel_one()
> {
> boost::system::error_code ec;
> std::size_t s = this->service.cancel_one(this->implementation, ec);
> boost::asio::detail::throw_error(ec, "cancel_one");
> return s;
> }
># 304 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t cancel_one(boost::system::error_code& ec)
> {
> return this->service.cancel_one(this->implementation, ec);
> }
>
>
>
>
>
>
> time_type expires_at() const
> {
> return this->service.expires_at(this->implementation);
> }
># 341 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t expires_at(const time_type& expiry_time)
> {
> boost::system::error_code ec;
> std::size_t s = this->service.expires_at(
> this->implementation, expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_at");
> return s;
> }
># 372 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t expires_at(const time_type& expiry_time,
> boost::system::error_code& ec)
> {
> return this->service.expires_at(this->implementation, expiry_time, ec);
> }
>
>
>
>
>
>
> duration_type expires_from_now() const
> {
> return this->service.expires_from_now(this->implementation);
> }
># 410 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t expires_from_now(const duration_type& expiry_time)
> {
> boost::system::error_code ec;
> std::size_t s = this->service.expires_from_now(
> this->implementation, expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_from_now");
> return s;
> }
># 441 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t expires_from_now(const duration_type& expiry_time,
> boost::system::error_code& ec)
> {
> return this->service.expires_from_now(
> this->implementation, expiry_time, ec);
> }
># 455 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> void wait()
> {
> boost::system::error_code ec;
> this->service.wait(this->implementation, ec);
> boost::asio::detail::throw_error(ec, "wait");
> }
># 469 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> void wait(boost::system::error_code& ec)
> {
> this->service.wait(this->implementation, ec);
> }
># 498 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> template <typename WaitHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
>
> async_wait(WaitHandler&& handler)
> {
>
>
> typedef typename handler_type<WaitHandler, void(boost::system::error_code)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> type_check;
>
> return this->service.async_wait(this->implementation,
> static_cast<WaitHandler&&>(handler));
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 516 "/usr/include/boost/asio/basic_deadline_timer.hpp" 2 3 4
># 23 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/basic_raw_socket.hpp" 1 3 4
># 19 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/basic_raw_socket.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/raw_socket_service.hpp" 1 3 4
># 19 "/usr/include/boost/asio/raw_socket_service.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/raw_socket_service.hpp" 2 3 4
># 31 "/usr/include/boost/asio/raw_socket_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 32 "/usr/include/boost/asio/raw_socket_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>template <typename Protocol>
>class raw_socket_service
>
>
>
> : public boost::asio::detail::service_base<raw_socket_service<Protocol> >
>
>{
>public:
>
>
>
>
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
>
>private:
>
>
>
>
> typedef detail::reactive_socket_service<Protocol> service_impl_type;
>
>
>public:
>
>
>
>
> typedef typename service_impl_type::implementation_type implementation_type;
>
>
>
>
>
>
> typedef typename service_impl_type::native_handle_type native_type;
>
>
>
>
>
>
> typedef typename service_impl_type::native_handle_type native_handle_type;
>
>
>
> explicit raw_socket_service(boost::asio::io_service& io_service)
> : boost::asio::detail::service_base<
> raw_socket_service<Protocol> >(io_service),
> service_impl_(io_service)
> {
> }
>
>
> void construct(implementation_type& impl)
> {
> service_impl_.construct(impl);
> }
>
>
>
> void move_construct(implementation_type& impl,
> implementation_type& other_impl)
> {
> service_impl_.move_construct(impl, other_impl);
> }
>
>
> void move_assign(implementation_type& impl,
> raw_socket_service& other_service,
> implementation_type& other_impl)
> {
> service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
> }
>
>
>
> template <typename Protocol1>
> void converting_move_construct(implementation_type& impl,
> typename raw_socket_service<
> Protocol1>::implementation_type& other_impl,
> typename enable_if<is_convertible<
> Protocol1, Protocol>::value>::type* = 0)
> {
> service_impl_.template converting_move_construct<Protocol1>(
> impl, other_impl);
> }
>
>
>
> void destroy(implementation_type& impl)
> {
> service_impl_.destroy(impl);
> }
>
>
> boost::system::error_code open(implementation_type& impl,
> const protocol_type& protocol, boost::system::error_code& ec)
> {
> if (protocol.type() == SOCK_RAW)
> service_impl_.open(impl, protocol, ec);
> else
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
>
>
> boost::system::error_code assign(implementation_type& impl,
> const protocol_type& protocol, const native_handle_type& native_socket,
> boost::system::error_code& ec)
> {
> return service_impl_.assign(impl, protocol, native_socket, ec);
> }
>
>
> bool is_open(const implementation_type& impl) const
> {
> return service_impl_.is_open(impl);
> }
>
>
> boost::system::error_code close(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.close(impl, ec);
> }
>
>
> native_type native(implementation_type& impl)
> {
> return service_impl_.native_handle(impl);
> }
>
>
> native_handle_type native_handle(implementation_type& impl)
> {
> return service_impl_.native_handle(impl);
> }
>
>
> boost::system::error_code cancel(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.cancel(impl, ec);
> }
>
>
> bool at_mark(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.at_mark(impl, ec);
> }
>
>
> std::size_t available(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.available(impl, ec);
> }
>
>
> boost::system::error_code bind(implementation_type& impl,
> const endpoint_type& endpoint, boost::system::error_code& ec)
> {
> return service_impl_.bind(impl, endpoint, ec);
> }
>
>
> boost::system::error_code connect(implementation_type& impl,
> const endpoint_type& peer_endpoint, boost::system::error_code& ec)
> {
> return service_impl_.connect(impl, peer_endpoint, ec);
> }
>
>
> template <typename ConnectHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
>
> async_connect(implementation_type& impl,
> const endpoint_type& peer_endpoint,
> ConnectHandler&& handler)
> {
> detail::async_result_init<
> ConnectHandler, void (boost::system::error_code)> init(
> static_cast<ConnectHandler&&>(handler));
>
> service_impl_.async_connect(impl, peer_endpoint, init.handler);
>
> return init.result.get();
> }
>
>
> template <typename SettableSocketOption>
> boost::system::error_code set_option(implementation_type& impl,
> const SettableSocketOption& option, boost::system::error_code& ec)
> {
> return service_impl_.set_option(impl, option, ec);
> }
>
>
> template <typename GettableSocketOption>
> boost::system::error_code get_option(const implementation_type& impl,
> GettableSocketOption& option, boost::system::error_code& ec) const
> {
> return service_impl_.get_option(impl, option, ec);
> }
>
>
> template <typename IoControlCommand>
> boost::system::error_code io_control(implementation_type& impl,
> IoControlCommand& command, boost::system::error_code& ec)
> {
> return service_impl_.io_control(impl, command, ec);
> }
>
>
> bool non_blocking(const implementation_type& impl) const
> {
> return service_impl_.non_blocking(impl);
> }
>
>
> boost::system::error_code non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> return service_impl_.non_blocking(impl, mode, ec);
> }
>
>
> bool native_non_blocking(const implementation_type& impl) const
> {
> return service_impl_.native_non_blocking(impl);
> }
>
>
> boost::system::error_code native_non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> return service_impl_.native_non_blocking(impl, mode, ec);
> }
>
>
> endpoint_type local_endpoint(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.local_endpoint(impl, ec);
> }
>
>
> endpoint_type remote_endpoint(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.remote_endpoint(impl, ec);
> }
>
>
> boost::system::error_code shutdown(implementation_type& impl,
> socket_base::shutdown_type what, boost::system::error_code& ec)
> {
> return service_impl_.shutdown(impl, what, ec);
> }
>
>
> template <typename ConstBufferSequence>
> std::size_t send(implementation_type& impl,
> const ConstBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return service_impl_.send(impl, buffers, flags, ec);
> }
>
>
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send(implementation_type& impl, const ConstBufferSequence& buffers,
> socket_base::message_flags flags,
> WriteHandler&& handler)
> {
> detail::async_result_init<
> WriteHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<WriteHandler&&>(handler));
>
> service_impl_.async_send(impl, buffers, flags, init.handler);
>
> return init.result.get();
> }
>
>
> template <typename ConstBufferSequence>
> std::size_t send_to(implementation_type& impl,
> const ConstBufferSequence& buffers, const endpoint_type& destination,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return service_impl_.send_to(impl, buffers, destination, flags, ec);
> }
>
>
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send_to(implementation_type& impl,
> const ConstBufferSequence& buffers, const endpoint_type& destination,
> socket_base::message_flags flags,
> WriteHandler&& handler)
> {
> detail::async_result_init<
> WriteHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<WriteHandler&&>(handler));
>
> service_impl_.async_send_to(impl, buffers,
> destination, flags, init.handler);
>
> return init.result.get();
> }
>
>
> template <typename MutableBufferSequence>
> std::size_t receive(implementation_type& impl,
> const MutableBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return service_impl_.receive(impl, buffers, flags, ec);
> }
>
>
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive(implementation_type& impl,
> const MutableBufferSequence& buffers,
> socket_base::message_flags flags,
> ReadHandler&& handler)
> {
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> service_impl_.async_receive(impl, buffers, flags, init.handler);
>
> return init.result.get();
> }
>
>
> template <typename MutableBufferSequence>
> std::size_t receive_from(implementation_type& impl,
> const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return service_impl_.receive_from(impl, buffers, sender_endpoint, flags,
> ec);
> }
>
>
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive_from(implementation_type& impl,
> const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
> socket_base::message_flags flags,
> ReadHandler&& handler)
> {
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> service_impl_.async_receive_from(impl, buffers,
> sender_endpoint, flags, init.handler);
>
> return init.result.get();
> }
>
>private:
>
> void shutdown_service()
> {
> service_impl_.shutdown_service();
> }
>
>
> service_impl_type service_impl_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 429 "/usr/include/boost/asio/raw_socket_service.hpp" 2 3 4
># 26 "/usr/include/boost/asio/basic_raw_socket.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/basic_raw_socket.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 41 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
>template <typename Protocol,
> typename RawSocketService = raw_socket_service<Protocol> >
>class basic_raw_socket
> : public basic_socket<Protocol, RawSocketService>
>{
>public:
>
>
> typedef typename RawSocketService::native_handle_type native_type;
>
>
> typedef typename RawSocketService::native_handle_type native_handle_type;
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
># 69 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> explicit basic_raw_socket(boost::asio::io_service& io_service)
> : basic_socket<Protocol, RawSocketService>(io_service)
> {
> }
># 86 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> basic_raw_socket(boost::asio::io_service& io_service,
> const protocol_type& protocol)
> : basic_socket<Protocol, RawSocketService>(io_service, protocol)
> {
> }
># 108 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> basic_raw_socket(boost::asio::io_service& io_service,
> const endpoint_type& endpoint)
> : basic_socket<Protocol, RawSocketService>(io_service, endpoint)
> {
> }
># 129 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> basic_raw_socket(boost::asio::io_service& io_service,
> const protocol_type& protocol, const native_handle_type& native_socket)
> : basic_socket<Protocol, RawSocketService>(
> io_service, protocol, native_socket)
> {
> }
># 147 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> basic_raw_socket(basic_raw_socket&& other)
> : basic_socket<Protocol, RawSocketService>(
> static_cast<basic_raw_socket&&>(other))
> {
> }
># 163 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> basic_raw_socket& operator=(basic_raw_socket&& other)
> {
> basic_socket<Protocol, RawSocketService>::operator=(
> static_cast<basic_raw_socket&&>(other));
> return *this;
> }
># 180 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename Protocol1, typename RawSocketService1>
> basic_raw_socket(basic_raw_socket<Protocol1, RawSocketService1>&& other,
> typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
> : basic_socket<Protocol, RawSocketService>(
> static_cast<basic_raw_socket< Protocol1, RawSocketService1>&&>
> (other))
> {
> }
># 199 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename Protocol1, typename RawSocketService1>
> typename enable_if<is_convertible<Protocol1, Protocol>::value,
> basic_raw_socket>::type& operator=(
> basic_raw_socket<Protocol1, RawSocketService1>&& other)
> {
> basic_socket<Protocol, RawSocketService>::operator=(
> static_cast<basic_raw_socket< Protocol1, RawSocketService1>&&>
> (other));
> return *this;
> }
># 232 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "send");
> return s;
> }
># 258 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> boost::asio::detail::throw_error(ec, "send");
> return s;
> }
># 285 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> }
># 328 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send(const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_send(this->get_implementation(),
> buffers, 0, static_cast<WriteHandler&&>(handler));
> }
># 370 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags,
> WriteHandler&& handler)
> {
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_send(this->get_implementation(),
> buffers, flags, static_cast<WriteHandler&&>(handler));
> }
># 410 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send_to(
> this->get_implementation(), buffers, destination, 0, ec);
> boost::asio::detail::throw_error(ec, "send_to");
> return s;
> }
># 437 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send_to(
> this->get_implementation(), buffers, destination, flags, ec);
> boost::asio::detail::throw_error(ec, "send_to");
> return s;
> }
># 464 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags,
> boost::system::error_code& ec)
> {
> return this->get_service().send_to(this->get_implementation(),
> buffers, destination, flags, ec);
> }
># 510 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination,
> WriteHandler&& handler)
> {
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_send_to(this->get_implementation(),
> buffers, destination, 0, static_cast<WriteHandler&&>(handler));
> }
># 552 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags,
> WriteHandler&& handler)
> {
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_send_to(
> this->get_implementation(), buffers, destination, flags,
> static_cast<WriteHandler&&>(handler));
> }
># 592 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 620 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, flags, ec);
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 649 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return this->get_service().receive(
> this->get_implementation(), buffers, flags, ec);
> }
># 693 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive(const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_receive(this->get_implementation(),
> buffers, 0, static_cast<ReadHandler&&>(handler));
> }
># 735 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags,
> ReadHandler&& handler)
> {
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_receive(this->get_implementation(),
> buffers, flags, static_cast<ReadHandler&&>(handler));
> }
># 776 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive_from(
> this->get_implementation(), buffers, sender_endpoint, 0, ec);
> boost::asio::detail::throw_error(ec, "receive_from");
> return s;
> }
># 803 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint, socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive_from(
> this->get_implementation(), buffers, sender_endpoint, flags, ec);
> boost::asio::detail::throw_error(ec, "receive_from");
> return s;
> }
># 830 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint, socket_base::message_flags flags,
> boost::system::error_code& ec)
> {
> return this->get_service().receive_from(this->get_implementation(),
> buffers, sender_endpoint, flags, ec);
> }
># 875 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint,
> ReadHandler&& handler)
> {
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_receive_from(
> this->get_implementation(), buffers, sender_endpoint, 0,
> static_cast<ReadHandler&&>(handler));
> }
># 920 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint, socket_base::message_flags flags,
> ReadHandler&& handler)
> {
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_receive_from(
> this->get_implementation(), buffers, sender_endpoint, flags,
> static_cast<ReadHandler&&>(handler));
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 941 "/usr/include/boost/asio/basic_raw_socket.hpp" 2 3 4
># 25 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 1 3 4
># 19 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/seq_packet_socket_service.hpp" 1 3 4
># 19 "/usr/include/boost/asio/seq_packet_socket_service.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/seq_packet_socket_service.hpp" 2 3 4
># 31 "/usr/include/boost/asio/seq_packet_socket_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 32 "/usr/include/boost/asio/seq_packet_socket_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>template <typename Protocol>
>class seq_packet_socket_service
>
>
>
> : public boost::asio::detail::service_base<
> seq_packet_socket_service<Protocol> >
>
>{
>public:
>
>
>
>
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
>
>private:
>
>
>
>
> typedef detail::reactive_socket_service<Protocol> service_impl_type;
>
>
>public:
>
>
>
>
> typedef typename service_impl_type::implementation_type implementation_type;
>
>
>
>
>
>
> typedef typename service_impl_type::native_handle_type native_type;
>
>
>
>
>
>
> typedef typename service_impl_type::native_handle_type native_handle_type;
>
>
>
>
> explicit seq_packet_socket_service(boost::asio::io_service& io_service)
> : boost::asio::detail::service_base<
> seq_packet_socket_service<Protocol> >(io_service),
> service_impl_(io_service)
> {
> }
>
>
> void construct(implementation_type& impl)
> {
> service_impl_.construct(impl);
> }
>
>
>
> void move_construct(implementation_type& impl,
> implementation_type& other_impl)
> {
> service_impl_.move_construct(impl, other_impl);
> }
>
>
> void move_assign(implementation_type& impl,
> seq_packet_socket_service& other_service,
> implementation_type& other_impl)
> {
> service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
> }
>
>
>
> template <typename Protocol1>
> void converting_move_construct(implementation_type& impl,
> typename seq_packet_socket_service<
> Protocol1>::implementation_type& other_impl,
> typename enable_if<is_convertible<
> Protocol1, Protocol>::value>::type* = 0)
> {
> service_impl_.template converting_move_construct<Protocol1>(
> impl, other_impl);
> }
>
>
>
> void destroy(implementation_type& impl)
> {
> service_impl_.destroy(impl);
> }
>
>
> boost::system::error_code open(implementation_type& impl,
> const protocol_type& protocol, boost::system::error_code& ec)
> {
> if (protocol.type() == SOCK_SEQPACKET)
> service_impl_.open(impl, protocol, ec);
> else
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
>
>
> boost::system::error_code assign(implementation_type& impl,
> const protocol_type& protocol, const native_handle_type& native_socket,
> boost::system::error_code& ec)
> {
> return service_impl_.assign(impl, protocol, native_socket, ec);
> }
>
>
> bool is_open(const implementation_type& impl) const
> {
> return service_impl_.is_open(impl);
> }
>
>
> boost::system::error_code close(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.close(impl, ec);
> }
>
>
> native_type native(implementation_type& impl)
> {
> return service_impl_.native_handle(impl);
> }
>
>
> native_handle_type native_handle(implementation_type& impl)
> {
> return service_impl_.native_handle(impl);
> }
>
>
> boost::system::error_code cancel(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.cancel(impl, ec);
> }
>
>
> bool at_mark(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.at_mark(impl, ec);
> }
>
>
> std::size_t available(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.available(impl, ec);
> }
>
>
> boost::system::error_code bind(implementation_type& impl,
> const endpoint_type& endpoint, boost::system::error_code& ec)
> {
> return service_impl_.bind(impl, endpoint, ec);
> }
>
>
> boost::system::error_code connect(implementation_type& impl,
> const endpoint_type& peer_endpoint, boost::system::error_code& ec)
> {
> return service_impl_.connect(impl, peer_endpoint, ec);
> }
>
>
> template <typename ConnectHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
>
> async_connect(implementation_type& impl,
> const endpoint_type& peer_endpoint,
> ConnectHandler&& handler)
> {
> detail::async_result_init<
> ConnectHandler, void (boost::system::error_code)> init(
> static_cast<ConnectHandler&&>(handler));
>
> service_impl_.async_connect(impl, peer_endpoint, init.handler);
>
> return init.result.get();
> }
>
>
> template <typename SettableSocketOption>
> boost::system::error_code set_option(implementation_type& impl,
> const SettableSocketOption& option, boost::system::error_code& ec)
> {
> return service_impl_.set_option(impl, option, ec);
> }
>
>
> template <typename GettableSocketOption>
> boost::system::error_code get_option(const implementation_type& impl,
> GettableSocketOption& option, boost::system::error_code& ec) const
> {
> return service_impl_.get_option(impl, option, ec);
> }
>
>
> template <typename IoControlCommand>
> boost::system::error_code io_control(implementation_type& impl,
> IoControlCommand& command, boost::system::error_code& ec)
> {
> return service_impl_.io_control(impl, command, ec);
> }
>
>
> bool non_blocking(const implementation_type& impl) const
> {
> return service_impl_.non_blocking(impl);
> }
>
>
> boost::system::error_code non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> return service_impl_.non_blocking(impl, mode, ec);
> }
>
>
> bool native_non_blocking(const implementation_type& impl) const
> {
> return service_impl_.native_non_blocking(impl);
> }
>
>
> boost::system::error_code native_non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> return service_impl_.native_non_blocking(impl, mode, ec);
> }
>
>
> endpoint_type local_endpoint(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.local_endpoint(impl, ec);
> }
>
>
> endpoint_type remote_endpoint(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.remote_endpoint(impl, ec);
> }
>
>
> boost::system::error_code shutdown(implementation_type& impl,
> socket_base::shutdown_type what, boost::system::error_code& ec)
> {
> return service_impl_.shutdown(impl, what, ec);
> }
>
>
> template <typename ConstBufferSequence>
> std::size_t send(implementation_type& impl,
> const ConstBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return service_impl_.send(impl, buffers, flags, ec);
> }
>
>
> template <typename ConstBufferSequence, typename WriteHandler>
> void async_send(implementation_type& impl,
> const ConstBufferSequence& buffers,
> socket_base::message_flags flags,
> WriteHandler&& handler)
> {
> service_impl_.async_send(impl, buffers, flags,
> static_cast<WriteHandler&&>(handler));
> }
>
>
> template <typename MutableBufferSequence>
> std::size_t receive(implementation_type& impl,
> const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags, boost::system::error_code& ec)
> {
> return service_impl_.receive_with_flags(impl,
> buffers, in_flags, out_flags, ec);
> }
>
>
> template <typename MutableBufferSequence, typename ReadHandler>
> void async_receive(implementation_type& impl,
> const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags,
> ReadHandler&& handler)
> {
> service_impl_.async_receive_with_flags(impl, buffers, in_flags,
> out_flags, static_cast<ReadHandler&&>(handler));
> }
>
>private:
>
> void shutdown_service()
> {
> service_impl_.shutdown_service();
> }
>
>
> service_impl_type service_impl_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 362 "/usr/include/boost/asio/seq_packet_socket_service.hpp" 2 3 4
># 25 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 40 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
>template <typename Protocol,
> typename SeqPacketSocketService = seq_packet_socket_service<Protocol> >
>class basic_seq_packet_socket
> : public basic_socket<Protocol, SeqPacketSocketService>
>{
>public:
>
>
> typedef typename SeqPacketSocketService::native_handle_type native_type;
>
>
> typedef typename SeqPacketSocketService::native_handle_type
> native_handle_type;
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
># 70 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> explicit basic_seq_packet_socket(boost::asio::io_service& io_service)
> : basic_socket<Protocol, SeqPacketSocketService>(io_service)
> {
> }
># 89 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> basic_seq_packet_socket(boost::asio::io_service& io_service,
> const protocol_type& protocol)
> : basic_socket<Protocol, SeqPacketSocketService>(io_service, protocol)
> {
> }
># 111 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> basic_seq_packet_socket(boost::asio::io_service& io_service,
> const endpoint_type& endpoint)
> : basic_socket<Protocol, SeqPacketSocketService>(io_service, endpoint)
> {
> }
># 132 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> basic_seq_packet_socket(boost::asio::io_service& io_service,
> const protocol_type& protocol, const native_handle_type& native_socket)
> : basic_socket<Protocol, SeqPacketSocketService>(
> io_service, protocol, native_socket)
> {
> }
># 151 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> basic_seq_packet_socket(basic_seq_packet_socket&& other)
> : basic_socket<Protocol, SeqPacketSocketService>(
> static_cast<basic_seq_packet_socket&&>(other))
> {
> }
># 168 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> basic_seq_packet_socket& operator=(basic_seq_packet_socket&& other)
> {
> basic_socket<Protocol, SeqPacketSocketService>::operator=(
> static_cast<basic_seq_packet_socket&&>(other));
> return *this;
> }
># 187 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename Protocol1, typename SeqPacketSocketService1>
> basic_seq_packet_socket(
> basic_seq_packet_socket<Protocol1, SeqPacketSocketService1>&& other,
> typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
> : basic_socket<Protocol, SeqPacketSocketService>(
> static_cast<basic_seq_packet_socket< Protocol1, SeqPacketSocketService1>&&>
> (other))
> {
> }
># 209 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename Protocol1, typename SeqPacketSocketService1>
> typename enable_if<is_convertible<Protocol1, Protocol>::value,
> basic_seq_packet_socket>::type& operator=(
> basic_seq_packet_socket<Protocol1, SeqPacketSocketService1>&& other)
> {
> basic_socket<Protocol, SeqPacketSocketService>::operator=(
> static_cast<basic_seq_packet_socket< Protocol1, SeqPacketSocketService1>&&>
> (other));
> return *this;
> }
># 244 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> boost::asio::detail::throw_error(ec, "send");
> return s;
> }
># 273 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> }
># 314 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags,
> WriteHandler&& handler)
> {
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_send(this->get_implementation(),
> buffers, flags, static_cast<WriteHandler&&>(handler));
> }
># 358 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags& out_flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, 0, out_flags, ec);
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 404 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, in_flags, out_flags, ec);
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 439 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags, boost::system::error_code& ec)
> {
> return this->get_service().receive(this->get_implementation(),
> buffers, in_flags, out_flags, ec);
> }
># 486 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive(const MutableBufferSequence& buffers,
> socket_base::message_flags& out_flags,
> ReadHandler&& handler)
> {
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_receive(
> this->get_implementation(), buffers, 0, out_flags,
> static_cast<ReadHandler&&>(handler));
> }
># 544 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive(const MutableBufferSequence& buffers,
> socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags,
> ReadHandler&& handler)
> {
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_receive(
> this->get_implementation(), buffers, in_flags, out_flags,
> static_cast<ReadHandler&&>(handler));
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 566 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 2 3 4
># 26 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_serial_port.hpp" 1 3 4
># 29 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
># 1 "/usr/include/boost/asio/serial_port_base.hpp" 1 3 4
># 25 "/usr/include/boost/asio/serial_port_base.hpp" 3 4
># 1 "/usr/include/termios.h" 1 3 4
># 35 "/usr/include/termios.h" 3 4
>extern "C" {
>
>
>
># 1 "/usr/include/bits/termios.h" 1 3 4
># 23 "/usr/include/bits/termios.h" 3 4
>typedef unsigned char cc_t;
>typedef unsigned int speed_t;
>typedef unsigned int tcflag_t;
>
>
>struct termios
> {
> tcflag_t c_iflag;
> tcflag_t c_oflag;
> tcflag_t c_cflag;
> tcflag_t c_lflag;
> cc_t c_line;
> cc_t c_cc[32];
> speed_t c_ispeed;
> speed_t c_ospeed;
>
>
> };
># 40 "/usr/include/termios.h" 2 3 4
># 48 "/usr/include/termios.h" 3 4
>extern speed_t cfgetospeed (const struct termios *__termios_p) throw ();
>
>
>extern speed_t cfgetispeed (const struct termios *__termios_p) throw ();
>
>
>extern int cfsetospeed (struct termios *__termios_p, speed_t __speed) throw ();
>
>
>extern int cfsetispeed (struct termios *__termios_p, speed_t __speed) throw ();
>
>
>
>extern int cfsetspeed (struct termios *__termios_p, speed_t __speed) throw ();
>
>
>
>
>extern int tcgetattr (int __fd, struct termios *__termios_p) throw ();
>
>
>
>extern int tcsetattr (int __fd, int __optional_actions,
> const struct termios *__termios_p) throw ();
>
>
>
>
>extern void cfmakeraw (struct termios *__termios_p) throw ();
>
>
>
>extern int tcsendbreak (int __fd, int __duration) throw ();
>
>
>
>
>
>extern int tcdrain (int __fd);
>
>
>
>extern int tcflush (int __fd, int __queue_selector) throw ();
>
>
>
>extern int tcflow (int __fd, int __action) throw ();
>
>
>
>
>extern __pid_t tcgetsid (int __fd) throw ();
>
>
>
>
># 1 "/usr/include/sys/ttydefaults.h" 1 3 4
># 105 "/usr/include/termios.h" 2 3 4
>
>
>}
># 26 "/usr/include/boost/asio/serial_port_base.hpp" 2 3 4
># 39 "/usr/include/boost/asio/serial_port_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 40 "/usr/include/boost/asio/serial_port_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>
>class serial_port_base
>{
>public:
>
>
>
>
> class baud_rate
> {
> public:
> explicit baud_rate(unsigned int rate = 0);
> unsigned int value() const;
> inline boost::system::error_code store(
> termios& storage,
> boost::system::error_code& ec) const;
> inline boost::system::error_code load(
> const termios& storage,
> boost::system::error_code& ec);
> private:
> unsigned int value_;
> };
>
>
>
>
>
> class flow_control
> {
> public:
> enum type { none, software, hardware };
> inline explicit flow_control(type t = none);
> type value() const;
> inline boost::system::error_code store(
> termios& storage,
> boost::system::error_code& ec) const;
> inline boost::system::error_code load(
> const termios& storage,
> boost::system::error_code& ec);
> private:
> type value_;
> };
>
>
>
>
>
> class parity
> {
> public:
> enum type { none, odd, even };
> inline explicit parity(type t = none);
> type value() const;
> inline boost::system::error_code store(
> termios& storage,
> boost::system::error_code& ec) const;
> inline boost::system::error_code load(
> const termios& storage,
> boost::system::error_code& ec);
> private:
> type value_;
> };
>
>
>
>
>
> class stop_bits
> {
> public:
> enum type { one, onepointfive, two };
> inline explicit stop_bits(type t = one);
> type value() const;
> inline boost::system::error_code store(
> termios& storage,
> boost::system::error_code& ec) const;
> inline boost::system::error_code load(
> const termios& storage,
> boost::system::error_code& ec);
> private:
> type value_;
> };
>
>
>
>
>
> class character_size
> {
> public:
> inline explicit character_size(unsigned int t = 8);
> unsigned int value() const;
> inline boost::system::error_code store(
> termios& storage,
> boost::system::error_code& ec) const;
> inline boost::system::error_code load(
> const termios& storage,
> boost::system::error_code& ec);
> private:
> unsigned int value_;
> };
>
>protected:
>
> ~serial_port_base()
> {
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 158 "/usr/include/boost/asio/serial_port_base.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/impl/serial_port_base.hpp" 1 3 4
># 19 "/usr/include/boost/asio/impl/serial_port_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 20 "/usr/include/boost/asio/impl/serial_port_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>inline serial_port_base::baud_rate::baud_rate(unsigned int rate)
> : value_(rate)
>{
>}
>
>inline unsigned int serial_port_base::baud_rate::value() const
>{
> return value_;
>}
>
>inline serial_port_base::flow_control::type
>serial_port_base::flow_control::value() const
>{
> return value_;
>}
>
>inline serial_port_base::parity::type serial_port_base::parity::value() const
>{
> return value_;
>}
>
>inline serial_port_base::stop_bits::type
>serial_port_base::stop_bits::value() const
>{
> return value_;
>}
>
>inline unsigned int serial_port_base::character_size::value() const
>{
> return value_;
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 60 "/usr/include/boost/asio/impl/serial_port_base.hpp" 2 3 4
># 162 "/usr/include/boost/asio/serial_port_base.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/serial_port_base.ipp" 1 3 4
># 25 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
># 1 "/usr/include/boost/asio/serial_port_base.hpp" 1 3 4
># 26 "/usr/include/boost/asio/impl/serial_port_base.ipp" 2 3 4
># 36 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 37 "/usr/include/boost/asio/impl/serial_port_base.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>boost::system::error_code serial_port_base::baud_rate::store(
> termios& storage, boost::system::error_code& ec) const
>{
>
>
>
> speed_t baud;
> switch (value_)
> {
>
> case 0: baud = 0000000; break;
> case 50: baud = 0000001; break;
> case 75: baud = 0000002; break;
> case 110: baud = 0000003; break;
> case 134: baud = 0000004; break;
> case 150: baud = 0000005; break;
> case 200: baud = 0000006; break;
> case 300: baud = 0000007; break;
> case 600: baud = 0000010; break;
> case 1200: baud = 0000011; break;
> case 1800: baud = 0000012; break;
> case 2400: baud = 0000013; break;
> case 4800: baud = 0000014; break;
> case 9600: baud = 0000015; break;
> case 19200: baud = 0000016; break;
> case 38400: baud = 0000017; break;
># 75 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> case 57600: baud = 0010001; break;
>
>
> case 115200: baud = 0010002; break;
>
>
> case 230400: baud = 0010003; break;
>
>
> case 460800: baud = 0010004; break;
>
>
> case 500000: baud = 0010005; break;
>
>
> case 576000: baud = 0010006; break;
>
>
> case 921600: baud = 0010007; break;
>
>
> case 1000000: baud = 0010010; break;
>
>
> case 1152000: baud = 0010011; break;
>
>
> case 2000000: baud = 0010013; break;
>
>
> case 3000000: baud = 0010015; break;
>
>
> case 3500000: baud = 0010016; break;
>
>
> case 4000000: baud = 0010017; break;
>
> default:
> baud = 0000000;
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
>
> ::cfsetspeed(&storage, baud);
>
>
>
>
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code serial_port_base::baud_rate::load(
> const termios& storage, boost::system::error_code& ec)
>{
>
>
>
> speed_t baud = ::cfgetospeed(&storage);
> switch (baud)
> {
>
> case 0000000: value_ = 0; break;
> case 0000001: value_ = 50; break;
> case 0000002: value_ = 75; break;
> case 0000003: value_ = 110; break;
> case 0000004: value_ = 134; break;
> case 0000005: value_ = 150; break;
> case 0000006: value_ = 200; break;
> case 0000007: value_ = 300; break;
> case 0000010: value_ = 600; break;
> case 0000011: value_ = 1200; break;
> case 0000012: value_ = 1800; break;
> case 0000013: value_ = 2400; break;
> case 0000014: value_ = 4800; break;
> case 0000015: value_ = 9600; break;
> case 0000016: value_ = 19200; break;
> case 0000017: value_ = 38400; break;
># 163 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> case 0010001: value_ = 57600; break;
>
>
> case 0010002: value_ = 115200; break;
>
>
> case 0010003: value_ = 230400; break;
>
>
> case 0010004: value_ = 460800; break;
>
>
> case 0010005: value_ = 500000; break;
>
>
> case 0010006: value_ = 576000; break;
>
>
> case 0010007: value_ = 921600; break;
>
>
> case 0010010: value_ = 1000000; break;
>
>
> case 0010011: value_ = 1152000; break;
>
>
> case 0010013: value_ = 2000000; break;
>
>
> case 0010015: value_ = 3000000; break;
>
>
> case 0010016: value_ = 3500000; break;
>
>
> case 0010017: value_ = 4000000; break;
>
> default:
> value_ = 0;
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>serial_port_base::flow_control::flow_control(
> serial_port_base::flow_control::type t)
> : value_(t)
>{
> if (t != none && t != software && t != hardware)
> {
> std::out_of_range ex("invalid flow_control value");
> boost::asio::detail::throw_exception(ex);
> }
>}
>
>boost::system::error_code serial_port_base::flow_control::store(
> termios& storage, boost::system::error_code& ec) const
>{
># 250 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> switch (value_)
> {
> case none:
> storage.c_iflag &= ~(0010000 | 0002000);
>
> storage.c_cflag &= ~020000000000;
>
>
>
> break;
> case software:
> storage.c_iflag |= 0010000 | 0002000;
>
> storage.c_cflag &= ~020000000000;
>
>
>
> break;
> case hardware:
>
> storage.c_iflag &= ~(0010000 | 0002000);
> storage.c_cflag |= 020000000000;
> break;
># 281 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> default:
> break;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code serial_port_base::flow_control::load(
> const termios& storage, boost::system::error_code& ec)
>{
># 306 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> if (storage.c_iflag & (0010000 | 0002000))
> {
> value_ = software;
> }
>
> else if (storage.c_cflag & 020000000000)
> {
> value_ = hardware;
> }
>
>
>
>
>
>
> else
> {
> value_ = none;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>serial_port_base::parity::parity(serial_port_base::parity::type t)
> : value_(t)
>{
> if (t != none && t != odd && t != even)
> {
> std::out_of_range ex("invalid parity value");
> boost::asio::detail::throw_exception(ex);
> }
>}
>
>boost::system::error_code serial_port_base::parity::store(
> termios& storage, boost::system::error_code& ec) const
>{
># 362 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> switch (value_)
> {
> case none:
> storage.c_iflag |= 0000004;
> storage.c_cflag &= ~(0000400 | 0001000);
> break;
> case even:
> storage.c_iflag &= ~(0000004 | 0000010);
> storage.c_iflag |= 0000020;
> storage.c_cflag |= 0000400;
> storage.c_cflag &= ~0001000;
> break;
> case odd:
> storage.c_iflag &= ~(0000004 | 0000010);
> storage.c_iflag |= 0000020;
> storage.c_cflag |= (0000400 | 0001000);
> break;
> default:
> break;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code serial_port_base::parity::load(
> const termios& storage, boost::system::error_code& ec)
>{
># 404 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> if (storage.c_cflag & 0000400)
> {
> if (storage.c_cflag & 0001000)
> {
> value_ = odd;
> }
> else
> {
> value_ = even;
> }
> }
> else
> {
> value_ = none;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>serial_port_base::stop_bits::stop_bits(
> serial_port_base::stop_bits::type t)
> : value_(t)
>{
> if (t != one && t != onepointfive && t != two)
> {
> std::out_of_range ex("invalid stop_bits value");
> boost::asio::detail::throw_exception(ex);
> }
>}
>
>boost::system::error_code serial_port_base::stop_bits::store(
> termios& storage, boost::system::error_code& ec) const
>{
># 454 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> switch (value_)
> {
> case one:
> storage.c_cflag &= ~0000100;
> break;
> case two:
> storage.c_cflag |= 0000100;
> break;
> default:
> ec = boost::asio::error::operation_not_supported;
> return ec;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code serial_port_base::stop_bits::load(
> const termios& storage, boost::system::error_code& ec)
>{
># 492 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> value_ = (storage.c_cflag & 0000100) ? two : one;
>
> ec = boost::system::error_code();
> return ec;
>}
>
>serial_port_base::character_size::character_size(unsigned int t)
> : value_(t)
>{
> if (t < 5 || t > 8)
> {
> std::out_of_range ex("invalid character_size value");
> boost::asio::detail::throw_exception(ex);
> }
>}
>
>boost::system::error_code serial_port_base::character_size::store(
> termios& storage, boost::system::error_code& ec) const
>{
>
>
>
> storage.c_cflag &= ~0000060;
> switch (value_)
> {
> case 5: storage.c_cflag |= 0000000; break;
> case 6: storage.c_cflag |= 0000020; break;
> case 7: storage.c_cflag |= 0000040; break;
> case 8: storage.c_cflag |= 0000060; break;
> default: break;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code serial_port_base::character_size::load(
> const termios& storage, boost::system::error_code& ec)
>{
>
>
>
> if ((storage.c_cflag & 0000060) == 0000000) { value_ = 5; }
> else if ((storage.c_cflag & 0000060) == 0000020) { value_ = 6; }
> else if ((storage.c_cflag & 0000060) == 0000040) { value_ = 7; }
> else if ((storage.c_cflag & 0000060) == 0000060) { value_ = 8; }
> else
> {
>
> value_ = 8;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 552 "/usr/include/boost/asio/impl/serial_port_base.ipp" 2 3 4
># 164 "/usr/include/boost/asio/serial_port_base.hpp" 2 3 4
># 30 "/usr/include/boost/asio/basic_serial_port.hpp" 2 3 4
># 1 "/usr/include/boost/asio/serial_port_service.hpp" 1 3 4
># 23 "/usr/include/boost/asio/serial_port_service.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 24 "/usr/include/boost/asio/serial_port_service.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/reactive_serial_port_service.hpp" 1 3 4
># 28 "/usr/include/boost/asio/detail/reactive_serial_port_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/descriptor_ops.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/descriptor_ops.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 23 "/usr/include/boost/asio/detail/descriptor_ops.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/descriptor_ops.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>namespace descriptor_ops {
>
>
>enum
>{
>
> user_set_non_blocking = 1,
>
>
> internal_non_blocking = 2,
>
>
> non_blocking = user_set_non_blocking | internal_non_blocking,
>
>
> possible_dup = 4
>};
>
>typedef unsigned char state_type;
>
>template <typename ReturnType>
>inline ReturnType error_wrapper(ReturnType return_value,
> boost::system::error_code& ec)
>{
> ec = boost::system::error_code((*__errno_location ()),
> boost::asio::error::get_system_category());
> return return_value;
>}
>
>inline int open(const char* path, int flags,
> boost::system::error_code& ec);
>
>inline int close(int d, state_type& state,
> boost::system::error_code& ec);
>
>inline bool set_user_non_blocking(int d,
> state_type& state, bool value, boost::system::error_code& ec);
>
>inline bool set_internal_non_blocking(int d,
> state_type& state, bool value, boost::system::error_code& ec);
>
>typedef iovec buf;
>
>inline std::size_t sync_read(int d, state_type state, buf* bufs,
> std::size_t count, bool all_empty, boost::system::error_code& ec);
>
>inline bool non_blocking_read(int d, buf* bufs, std::size_t count,
> boost::system::error_code& ec, std::size_t& bytes_transferred);
>
>inline std::size_t sync_write(int d, state_type state,
> const buf* bufs, std::size_t count, bool all_empty,
> boost::system::error_code& ec);
>
>inline bool non_blocking_write(int d,
> const buf* bufs, std::size_t count,
> boost::system::error_code& ec, std::size_t& bytes_transferred);
>
>inline int ioctl(int d, state_type& state, long cmd,
> ioctl_arg_type* arg, boost::system::error_code& ec);
>
>inline int fcntl(int d, int cmd, boost::system::error_code& ec);
>
>inline int fcntl(int d, int cmd,
> long arg, boost::system::error_code& ec);
>
>inline int poll_read(int d,
> state_type state, boost::system::error_code& ec);
>
>inline int poll_write(int d,
> state_type state, boost::system::error_code& ec);
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 108 "/usr/include/boost/asio/detail/descriptor_ops.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 1 3 4
># 19 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 3 4
># 1 "/usr/include/c++/4.8.2/cerrno" 1 3 4
># 39 "/usr/include/c++/4.8.2/cerrno" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cerrno" 3
>
># 1 "/usr/include/errno.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cerrno" 2 3
># 20 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/descriptor_ops.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>namespace descriptor_ops {
>
>int open(const char* path, int flags, boost::system::error_code& ec)
>{
> (*__errno_location ()) = 0;
> int result = error_wrapper(::open(path, flags), ec);
> if (result >= 0)
> ec = boost::system::error_code();
> return result;
>}
>
>int close(int d, state_type& state, boost::system::error_code& ec)
>{
> int result = 0;
> if (d != -1)
> {
> (*__errno_location ()) = 0;
> result = error_wrapper(::close(d), ec);
>
> if (result != 0
> && (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again))
> {
># 64 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 3 4
> ioctl_arg_type arg = 0;
> ::ioctl(d, 0x5421, &arg);
>
> state &= ~non_blocking;
>
> (*__errno_location ()) = 0;
> result = error_wrapper(::close(d), ec);
> }
> }
>
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>}
>
>bool set_user_non_blocking(int d, state_type& state,
> bool value, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return false;
> }
>
> (*__errno_location ()) = 0;
># 98 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 3 4
> ioctl_arg_type arg = (value ? 1 : 0);
> int result = error_wrapper(::ioctl(d, 0x5421, &arg), ec);
>
>
> if (result >= 0)
> {
> ec = boost::system::error_code();
> if (value)
> state |= user_set_non_blocking;
> else
> {
>
>
>
> state &= ~(user_set_non_blocking | internal_non_blocking);
> }
> return true;
> }
>
> return false;
>}
>
>bool set_internal_non_blocking(int d, state_type& state,
> bool value, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return false;
> }
>
> if (!value && (state & user_set_non_blocking))
> {
>
>
>
> ec = boost::asio::error::invalid_argument;
> return false;
> }
>
> (*__errno_location ()) = 0;
># 148 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 3 4
> ioctl_arg_type arg = (value ? 1 : 0);
> int result = error_wrapper(::ioctl(d, 0x5421, &arg), ec);
>
>
> if (result >= 0)
> {
> ec = boost::system::error_code();
> if (value)
> state |= internal_non_blocking;
> else
> state &= ~internal_non_blocking;
> return true;
> }
>
> return false;
>}
>
>std::size_t sync_read(int d, state_type state, buf* bufs,
> std::size_t count, bool all_empty, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
>
> if (all_empty)
> {
> ec = boost::system::error_code();
> return 0;
> }
>
>
> for (;;)
> {
>
> (*__errno_location ()) = 0;
> signed_size_type bytes = error_wrapper(::readv(
> d, bufs, static_cast<int>(count)), ec);
>
>
> if (bytes > 0)
> return bytes;
>
>
> if (bytes == 0)
> {
> ec = boost::asio::error::eof;
> return 0;
> }
>
>
> if ((state & user_set_non_blocking)
> || (ec != boost::asio::error::would_block
> && ec != boost::asio::error::try_again))
> return 0;
>
>
> if (descriptor_ops::poll_read(d, 0, ec) < 0)
> return 0;
> }
>}
>
>bool non_blocking_read(int d, buf* bufs, std::size_t count,
> boost::system::error_code& ec, std::size_t& bytes_transferred)
>{
> for (;;)
> {
>
> (*__errno_location ()) = 0;
> signed_size_type bytes = error_wrapper(::readv(
> d, bufs, static_cast<int>(count)), ec);
>
>
> if (bytes == 0)
> {
> ec = boost::asio::error::eof;
> return true;
> }
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> return false;
>
>
> if (bytes > 0)
> {
> ec = boost::system::error_code();
> bytes_transferred = bytes;
> }
> else
> bytes_transferred = 0;
>
> return true;
> }
>}
>
>std::size_t sync_write(int d, state_type state, const buf* bufs,
> std::size_t count, bool all_empty, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
>
> if (all_empty)
> {
> ec = boost::system::error_code();
> return 0;
> }
>
>
> for (;;)
> {
>
> (*__errno_location ()) = 0;
> signed_size_type bytes = error_wrapper(::writev(
> d, bufs, static_cast<int>(count)), ec);
>
>
> if (bytes > 0)
> return bytes;
>
>
> if ((state & user_set_non_blocking)
> || (ec != boost::asio::error::would_block
> && ec != boost::asio::error::try_again))
> return 0;
>
>
> if (descriptor_ops::poll_write(d, 0, ec) < 0)
> return 0;
> }
>}
>
>bool non_blocking_write(int d, const buf* bufs, std::size_t count,
> boost::system::error_code& ec, std::size_t& bytes_transferred)
>{
> for (;;)
> {
>
> (*__errno_location ()) = 0;
> signed_size_type bytes = error_wrapper(::writev(
> d, bufs, static_cast<int>(count)), ec);
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> return false;
>
>
> if (bytes >= 0)
> {
> ec = boost::system::error_code();
> bytes_transferred = bytes;
> }
> else
> bytes_transferred = 0;
>
> return true;
> }
>}
>
>int ioctl(int d, state_type& state, long cmd,
> ioctl_arg_type* arg, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return -1;
> }
>
> (*__errno_location ()) = 0;
> int result = error_wrapper(::ioctl(d, cmd, arg), ec);
>
> if (result >= 0)
> {
> ec = boost::system::error_code();
>
>
>
>
>
>
>
> if (cmd == static_cast<long>(0x5421))
> {
> if (*arg)
> {
> state |= user_set_non_blocking;
> }
> else
> {
>
>
>
> state &= ~(user_set_non_blocking | internal_non_blocking);
> }
> }
> }
>
> return result;
>}
>
>int fcntl(int d, int cmd, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return -1;
> }
>
> (*__errno_location ()) = 0;
> int result = error_wrapper(::fcntl(d, cmd), ec);
> if (result != -1)
> ec = boost::system::error_code();
> return result;
>}
>
>int fcntl(int d, int cmd, long arg, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return -1;
> }
>
> (*__errno_location ()) = 0;
> int result = error_wrapper(::fcntl(d, cmd, arg), ec);
> if (result != -1)
> ec = boost::system::error_code();
> return result;
>}
>
>int poll_read(int d, state_type state, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return -1;
> }
>
> pollfd fds;
> fds.fd = d;
> fds.events = 0x001;
> fds.revents = 0;
> int timeout = (state & user_set_non_blocking) ? 0 : -1;
> (*__errno_location ()) = 0;
> int result = error_wrapper(::poll(&fds, 1, timeout), ec);
> if (result == 0)
> ec = (state & user_set_non_blocking)
> ? boost::asio::error::would_block : boost::system::error_code();
> else if (result > 0)
> ec = boost::system::error_code();
> return result;
>}
>
>int poll_write(int d, state_type state, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return -1;
> }
>
> pollfd fds;
> fds.fd = d;
> fds.events = 0x004;
> fds.revents = 0;
> int timeout = (state & user_set_non_blocking) ? 0 : -1;
> (*__errno_location ()) = 0;
> int result = error_wrapper(::poll(&fds, 1, timeout), ec);
> if (result == 0)
> ec = (state & user_set_non_blocking)
> ? boost::asio::error::would_block : boost::system::error_code();
> else if (result > 0)
> ec = boost::system::error_code();
> return result;
>}
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 446 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 2 3 4
># 111 "/usr/include/boost/asio/detail/descriptor_ops.hpp" 2 3 4
># 29 "/usr/include/boost/asio/detail/reactive_serial_port_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 1 3 4
># 28 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/descriptor_read_op.hpp" 1 3 4
># 29 "/usr/include/boost/asio/detail/descriptor_read_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 30 "/usr/include/boost/asio/detail/descriptor_read_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename MutableBufferSequence>
>class descriptor_read_op_base : public reactor_op
>{
>public:
> descriptor_read_op_base(int descriptor,
> const MutableBufferSequence& buffers, func_type complete_func)
> : reactor_op(&descriptor_read_op_base::do_perform, complete_func),
> descriptor_(descriptor),
> buffers_(buffers)
> {
> }
>
> static bool do_perform(reactor_op* base)
> {
> descriptor_read_op_base* o(static_cast<descriptor_read_op_base*>(base));
>
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(o->buffers_);
>
> return descriptor_ops::non_blocking_read(o->descriptor_,
> bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_);
> }
>
>private:
> int descriptor_;
> MutableBufferSequence buffers_;
>};
>
>template <typename MutableBufferSequence, typename Handler>
>class descriptor_read_op
> : public descriptor_read_op_base<MutableBufferSequence>
>{
>public:
> struct ptr { Handler* h; void* v; descriptor_read_op* p; ~ptr() { reset(); } void reset() { if (p) { p->~descriptor_read_op(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(descriptor_read_op), *h); v = 0; } } };
>
> descriptor_read_op(int descriptor,
> const MutableBufferSequence& buffers, Handler& handler)
> : descriptor_read_op_base<MutableBufferSequence>(
> descriptor, buffers, &descriptor_read_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
> static void do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> descriptor_read_op* o(static_cast<descriptor_read_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 118 "/usr/include/boost/asio/detail/descriptor_read_op.hpp" 2 3 4
># 29 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/descriptor_write_op.hpp" 1 3 4
># 29 "/usr/include/boost/asio/detail/descriptor_write_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 30 "/usr/include/boost/asio/detail/descriptor_write_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename ConstBufferSequence>
>class descriptor_write_op_base : public reactor_op
>{
>public:
> descriptor_write_op_base(int descriptor,
> const ConstBufferSequence& buffers, func_type complete_func)
> : reactor_op(&descriptor_write_op_base::do_perform, complete_func),
> descriptor_(descriptor),
> buffers_(buffers)
> {
> }
>
> static bool do_perform(reactor_op* base)
> {
> descriptor_write_op_base* o(static_cast<descriptor_write_op_base*>(base));
>
> buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence> bufs(o->buffers_);
>
> return descriptor_ops::non_blocking_write(o->descriptor_,
> bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_);
> }
>
>private:
> int descriptor_;
> ConstBufferSequence buffers_;
>};
>
>template <typename ConstBufferSequence, typename Handler>
>class descriptor_write_op
> : public descriptor_write_op_base<ConstBufferSequence>
>{
>public:
> struct ptr { Handler* h; void* v; descriptor_write_op* p; ~ptr() { reset(); } void reset() { if (p) { p->~descriptor_write_op(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(descriptor_write_op), *h); v = 0; } } };
>
> descriptor_write_op(int descriptor,
> const ConstBufferSequence& buffers, Handler& handler)
> : descriptor_write_op_base<ConstBufferSequence>(
> descriptor, buffers, &descriptor_write_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
> static void do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> descriptor_write_op* o(static_cast<descriptor_write_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 118 "/usr/include/boost/asio/detail/descriptor_write_op.hpp" 2 3 4
># 30 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 36 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class reactive_descriptor_service
>{
>public:
>
> typedef int native_handle_type;
>
>
> class implementation_type
> : private boost::asio::detail::noncopyable
> {
> public:
>
> implementation_type()
> : descriptor_(-1),
> state_(0)
> {
> }
>
> private:
>
> friend class reactive_descriptor_service;
>
>
> int descriptor_;
>
>
> descriptor_ops::state_type state_;
>
>
> reactor::per_descriptor_data reactor_data_;
> };
>
>
> inline reactive_descriptor_service(
> boost::asio::io_service& io_service);
>
>
> inline void shutdown_service();
>
>
> inline void construct(implementation_type& impl);
>
>
> inline void move_construct(implementation_type& impl,
> implementation_type& other_impl);
>
>
> inline void move_assign(implementation_type& impl,
> reactive_descriptor_service& other_service,
> implementation_type& other_impl);
>
>
> inline void destroy(implementation_type& impl);
>
>
> inline boost::system::error_code assign(implementation_type& impl,
> const native_handle_type& native_descriptor,
> boost::system::error_code& ec);
>
>
> bool is_open(const implementation_type& impl) const
> {
> return impl.descriptor_ != -1;
> }
>
>
> inline boost::system::error_code close(implementation_type& impl,
> boost::system::error_code& ec);
>
>
> native_handle_type native_handle(const implementation_type& impl) const
> {
> return impl.descriptor_;
> }
>
>
> inline native_handle_type release(implementation_type& impl);
>
>
> inline boost::system::error_code cancel(implementation_type& impl,
> boost::system::error_code& ec);
>
>
> template <typename IO_Control_Command>
> boost::system::error_code io_control(implementation_type& impl,
> IO_Control_Command& command, boost::system::error_code& ec)
> {
> descriptor_ops::ioctl(impl.descriptor_, impl.state_,
> command.name(), static_cast<ioctl_arg_type*>(command.data()), ec);
> return ec;
> }
>
>
> bool non_blocking(const implementation_type& impl) const
> {
> return (impl.state_ & descriptor_ops::user_set_non_blocking) != 0;
> }
>
>
> boost::system::error_code non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> descriptor_ops::set_user_non_blocking(
> impl.descriptor_, impl.state_, mode, ec);
> return ec;
> }
>
>
> bool native_non_blocking(const implementation_type& impl) const
> {
> return (impl.state_ & descriptor_ops::internal_non_blocking) != 0;
> }
>
>
> boost::system::error_code native_non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> descriptor_ops::set_internal_non_blocking(
> impl.descriptor_, impl.state_, mode, ec);
> return ec;
> }
>
>
> template <typename ConstBufferSequence>
> size_t write_some(implementation_type& impl,
> const ConstBufferSequence& buffers, boost::system::error_code& ec)
> {
> buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence> bufs(buffers);
>
> return descriptor_ops::sync_write(impl.descriptor_, impl.state_,
> bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
> }
>
>
> size_t write_some(implementation_type& impl,
> const null_buffers&, boost::system::error_code& ec)
> {
>
> descriptor_ops::poll_write(impl.descriptor_, impl.state_, ec);
>
> return 0;
> }
>
>
>
> template <typename ConstBufferSequence, typename Handler>
> void async_write_some(implementation_type& impl,
> const ConstBufferSequence& buffers, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef descriptor_write_op<ConstBufferSequence, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(impl.descriptor_, buffers, handler);
>
> (void)0;
>
> start_op(impl, reactor::write_op, p.p, is_continuation, true,
> buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence>::all_empty(buffers));
> p.v = p.p = 0;
> }
>
>
> template <typename Handler>
> void async_write_some(implementation_type& impl,
> const null_buffers&, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_null_buffers_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
> start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>
> template <typename MutableBufferSequence>
> size_t read_some(implementation_type& impl,
> const MutableBufferSequence& buffers, boost::system::error_code& ec)
> {
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(buffers);
>
> return descriptor_ops::sync_read(impl.descriptor_, impl.state_,
> bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
> }
>
>
> size_t read_some(implementation_type& impl,
> const null_buffers&, boost::system::error_code& ec)
> {
>
> descriptor_ops::poll_read(impl.descriptor_, impl.state_, ec);
>
> return 0;
> }
>
>
>
> template <typename MutableBufferSequence, typename Handler>
> void async_read_some(implementation_type& impl,
> const MutableBufferSequence& buffers, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef descriptor_read_op<MutableBufferSequence, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(impl.descriptor_, buffers, handler);
>
> (void)0;
>
> start_op(impl, reactor::read_op, p.p, is_continuation, true,
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence>::all_empty(buffers));
> p.v = p.p = 0;
> }
>
>
> template <typename Handler>
> void async_read_some(implementation_type& impl,
> const null_buffers&, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_null_buffers_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
> start_op(impl, reactor::read_op, p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>private:
>
> inline void start_op(implementation_type& impl, int op_type,
> reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop);
>
>
> reactor& reactor_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 313 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/reactive_descriptor_service.ipp" 1 3 4
># 23 "/usr/include/boost/asio/detail/impl/reactive_descriptor_service.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/impl/reactive_descriptor_service.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/impl/reactive_descriptor_service.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>reactive_descriptor_service::reactive_descriptor_service(
> boost::asio::io_service& io_service)
> : reactor_(boost::asio::use_service<reactor>(io_service))
>{
> reactor_.init_task();
>}
>
>void reactive_descriptor_service::shutdown_service()
>{
>}
>
>void reactive_descriptor_service::construct(
> reactive_descriptor_service::implementation_type& impl)
>{
> impl.descriptor_ = -1;
> impl.state_ = 0;
>}
>
>void reactive_descriptor_service::move_construct(
> reactive_descriptor_service::implementation_type& impl,
> reactive_descriptor_service::implementation_type& other_impl)
>{
> impl.descriptor_ = other_impl.descriptor_;
> other_impl.descriptor_ = -1;
>
> impl.state_ = other_impl.state_;
> other_impl.state_ = 0;
>
> reactor_.move_descriptor(impl.descriptor_,
> impl.reactor_data_, other_impl.reactor_data_);
>}
>
>void reactive_descriptor_service::move_assign(
> reactive_descriptor_service::implementation_type& impl,
> reactive_descriptor_service& other_service,
> reactive_descriptor_service::implementation_type& other_impl)
>{
> destroy(impl);
>
> impl.descriptor_ = other_impl.descriptor_;
> other_impl.descriptor_ = -1;
>
> impl.state_ = other_impl.state_;
> other_impl.state_ = 0;
>
> other_service.reactor_.move_descriptor(impl.descriptor_,
> impl.reactor_data_, other_impl.reactor_data_);
>}
>
>void reactive_descriptor_service::destroy(
> reactive_descriptor_service::implementation_type& impl)
>{
> if (is_open(impl))
> {
> (void)0;
>
> reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_,
> (impl.state_ & descriptor_ops::possible_dup) == 0);
> }
>
> boost::system::error_code ignored_ec;
> descriptor_ops::close(impl.descriptor_, impl.state_, ignored_ec);
>}
>
>boost::system::error_code reactive_descriptor_service::assign(
> reactive_descriptor_service::implementation_type& impl,
> const native_handle_type& native_descriptor, boost::system::error_code& ec)
>{
> if (is_open(impl))
> {
> ec = boost::asio::error::already_open;
> return ec;
> }
>
> if (int err = reactor_.register_descriptor(
> native_descriptor, impl.reactor_data_))
> {
> ec = boost::system::error_code(err,
> boost::asio::error::get_system_category());
> return ec;
> }
>
> impl.descriptor_ = native_descriptor;
> impl.state_ = descriptor_ops::possible_dup;
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code reactive_descriptor_service::close(
> reactive_descriptor_service::implementation_type& impl,
> boost::system::error_code& ec)
>{
> if (is_open(impl))
> {
> (void)0;
>
> reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_,
> (impl.state_ & descriptor_ops::possible_dup) == 0);
> }
>
> descriptor_ops::close(impl.descriptor_, impl.state_, ec);
>
>
>
>
>
>
>
> construct(impl);
>
> return ec;
>}
>
>reactive_descriptor_service::native_handle_type
>reactive_descriptor_service::release(
> reactive_descriptor_service::implementation_type& impl)
>{
> native_handle_type descriptor = impl.descriptor_;
>
> if (is_open(impl))
> {
> (void)0;
>
> reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_, false);
> construct(impl);
> }
>
> return descriptor;
>}
>
>boost::system::error_code reactive_descriptor_service::cancel(
> reactive_descriptor_service::implementation_type& impl,
> boost::system::error_code& ec)
>{
> if (!is_open(impl))
> {
> ec = boost::asio::error::bad_descriptor;
> return ec;
> }
>
> (void)0;
>
> reactor_.cancel_ops(impl.descriptor_, impl.reactor_data_);
> ec = boost::system::error_code();
> return ec;
>}
>
>void reactive_descriptor_service::start_op(
> reactive_descriptor_service::implementation_type& impl,
> int op_type, reactor_op* op, bool is_continuation,
> bool is_non_blocking, bool noop)
>{
> if (!noop)
> {
> if ((impl.state_ & descriptor_ops::non_blocking) ||
> descriptor_ops::set_internal_non_blocking(
> impl.descriptor_, impl.state_, true, op->ec_))
> {
> reactor_.start_op(op_type, impl.descriptor_,
> impl.reactor_data_, op, is_continuation, is_non_blocking);
> return;
> }
> }
>
> reactor_.post_immediate_completion(op, is_continuation);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 203 "/usr/include/boost/asio/detail/impl/reactive_descriptor_service.ipp" 2 3 4
># 316 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4
># 30 "/usr/include/boost/asio/detail/reactive_serial_port_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 32 "/usr/include/boost/asio/detail/reactive_serial_port_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>class reactive_serial_port_service
>{
>public:
>
> typedef reactive_descriptor_service::native_handle_type native_handle_type;
>
>
> typedef reactive_descriptor_service::implementation_type implementation_type;
>
> inline reactive_serial_port_service(
> boost::asio::io_service& io_service);
>
>
> inline void shutdown_service();
>
>
> void construct(implementation_type& impl)
> {
> descriptor_service_.construct(impl);
> }
>
>
> void move_construct(implementation_type& impl,
> implementation_type& other_impl)
> {
> descriptor_service_.move_construct(impl, other_impl);
> }
>
>
> void move_assign(implementation_type& impl,
> reactive_serial_port_service& other_service,
> implementation_type& other_impl)
> {
> descriptor_service_.move_assign(impl,
> other_service.descriptor_service_, other_impl);
> }
>
>
> void destroy(implementation_type& impl)
> {
> descriptor_service_.destroy(impl);
> }
>
>
> inline boost::system::error_code open(implementation_type& impl,
> const std::string& device, boost::system::error_code& ec);
>
>
> boost::system::error_code assign(implementation_type& impl,
> const native_handle_type& native_descriptor,
> boost::system::error_code& ec)
> {
> return descriptor_service_.assign(impl, native_descriptor, ec);
> }
>
>
> bool is_open(const implementation_type& impl) const
> {
> return descriptor_service_.is_open(impl);
> }
>
>
> boost::system::error_code close(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return descriptor_service_.close(impl, ec);
> }
>
>
> native_handle_type native_handle(implementation_type& impl)
> {
> return descriptor_service_.native_handle(impl);
> }
>
>
> boost::system::error_code cancel(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return descriptor_service_.cancel(impl, ec);
> }
>
>
> template <typename SettableSerialPortOption>
> boost::system::error_code set_option(implementation_type& impl,
> const SettableSerialPortOption& option, boost::system::error_code& ec)
> {
> return do_set_option(impl,
> &reactive_serial_port_service::store_option<SettableSerialPortOption>,
> &option, ec);
> }
>
>
> template <typename GettableSerialPortOption>
> boost::system::error_code get_option(const implementation_type& impl,
> GettableSerialPortOption& option, boost::system::error_code& ec) const
> {
> return do_get_option(impl,
> &reactive_serial_port_service::load_option<GettableSerialPortOption>,
> &option, ec);
> }
>
>
> boost::system::error_code send_break(implementation_type& impl,
> boost::system::error_code& ec)
> {
> (*__errno_location ()) = 0;
> descriptor_ops::error_wrapper(::tcsendbreak(
> descriptor_service_.native_handle(impl), 0), ec);
> return ec;
> }
>
>
> template <typename ConstBufferSequence>
> size_t write_some(implementation_type& impl,
> const ConstBufferSequence& buffers, boost::system::error_code& ec)
> {
> return descriptor_service_.write_some(impl, buffers, ec);
> }
>
>
>
> template <typename ConstBufferSequence, typename Handler>
> void async_write_some(implementation_type& impl,
> const ConstBufferSequence& buffers, Handler& handler)
> {
> descriptor_service_.async_write_some(impl, buffers, handler);
> }
>
>
> template <typename MutableBufferSequence>
> size_t read_some(implementation_type& impl,
> const MutableBufferSequence& buffers, boost::system::error_code& ec)
> {
> return descriptor_service_.read_some(impl, buffers, ec);
> }
>
>
>
> template <typename MutableBufferSequence, typename Handler>
> void async_read_some(implementation_type& impl,
> const MutableBufferSequence& buffers, Handler& handler)
> {
> descriptor_service_.async_read_some(impl, buffers, handler);
> }
>
>private:
>
> typedef boost::system::error_code (*store_function_type)(
> const void*, termios&, boost::system::error_code&);
>
>
> template <typename SettableSerialPortOption>
> static boost::system::error_code store_option(const void* option,
> termios& storage, boost::system::error_code& ec)
> {
> return static_cast<const SettableSerialPortOption*>(option)->store(
> storage, ec);
> }
>
>
> inline boost::system::error_code do_set_option(
> implementation_type& impl, store_function_type store,
> const void* option, boost::system::error_code& ec);
>
>
> typedef boost::system::error_code (*load_function_type)(
> void*, const termios&, boost::system::error_code&);
>
>
> template <typename GettableSerialPortOption>
> static boost::system::error_code load_option(void* option,
> const termios& storage, boost::system::error_code& ec)
> {
> return static_cast<GettableSerialPortOption*>(option)->load(storage, ec);
> }
>
>
> inline boost::system::error_code do_get_option(
> const implementation_type& impl, load_function_type load,
> void* option, boost::system::error_code& ec) const;
>
>
> reactive_descriptor_service descriptor_service_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 228 "/usr/include/boost/asio/detail/reactive_serial_port_service.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 1 3 4
># 24 "/usr/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 25 "/usr/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_serial_port_service.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>reactive_serial_port_service::reactive_serial_port_service(
> boost::asio::io_service& io_service)
> : descriptor_service_(io_service)
>{
>}
>
>void reactive_serial_port_service::shutdown_service()
>{
> descriptor_service_.shutdown_service();
>}
>
>boost::system::error_code reactive_serial_port_service::open(
> reactive_serial_port_service::implementation_type& impl,
> const std::string& device, boost::system::error_code& ec)
>{
> if (is_open(impl))
> {
> ec = boost::asio::error::already_open;
> return ec;
> }
>
> descriptor_ops::state_type state = 0;
> int fd = descriptor_ops::open(device.c_str(),
> 02 | 04000 | 0400, ec);
> if (fd < 0)
> return ec;
>
> int s = descriptor_ops::fcntl(fd, 3, ec);
> if (s >= 0)
> s = descriptor_ops::fcntl(fd, 4, s | 04000, ec);
> if (s < 0)
> {
> boost::system::error_code ignored_ec;
> descriptor_ops::close(fd, state, ignored_ec);
> return ec;
> }
>
>
> termios ios;
> (*__errno_location ()) = 0;
> s = descriptor_ops::error_wrapper(::tcgetattr(fd, &ios), ec);
> if (s >= 0)
> {
>
> ::cfmakeraw(&ios);
># 86 "/usr/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 3 4
> ios.c_iflag |= 0000004;
> ios.c_cflag |= 0000200 | 0004000;
> (*__errno_location ()) = 0;
> s = descriptor_ops::error_wrapper(::tcsetattr(fd, 0, &ios), ec);
> }
> if (s < 0)
> {
> boost::system::error_code ignored_ec;
> descriptor_ops::close(fd, state, ignored_ec);
> return ec;
> }
>
>
> if (descriptor_service_.assign(impl, fd, ec))
> {
> boost::system::error_code ignored_ec;
> descriptor_ops::close(fd, state, ignored_ec);
> }
>
> return ec;
>}
>
>boost::system::error_code reactive_serial_port_service::do_set_option(
> reactive_serial_port_service::implementation_type& impl,
> reactive_serial_port_service::store_function_type store,
> const void* option, boost::system::error_code& ec)
>{
> termios ios;
> (*__errno_location ()) = 0;
> descriptor_ops::error_wrapper(::tcgetattr(
> descriptor_service_.native_handle(impl), &ios), ec);
> if (ec)
> return ec;
>
> if (store(option, ios, ec))
> return ec;
>
> (*__errno_location ()) = 0;
> descriptor_ops::error_wrapper(::tcsetattr(
> descriptor_service_.native_handle(impl), 0, &ios), ec);
> return ec;
>}
>
>boost::system::error_code reactive_serial_port_service::do_get_option(
> const reactive_serial_port_service::implementation_type& impl,
> reactive_serial_port_service::load_function_type load,
> void* option, boost::system::error_code& ec) const
>{
> termios ios;
> (*__errno_location ()) = 0;
> descriptor_ops::error_wrapper(::tcgetattr(
> descriptor_service_.native_handle(impl), &ios), ec);
> if (ec)
> return ec;
>
> return load(option, ios, ec);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 149 "/usr/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 2 3 4
># 231 "/usr/include/boost/asio/detail/reactive_serial_port_service.hpp" 2 3 4
># 27 "/usr/include/boost/asio/serial_port_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/win_iocp_serial_port_service.hpp" 1 3 4
># 28 "/usr/include/boost/asio/serial_port_service.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 33 "/usr/include/boost/asio/serial_port_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>class serial_port_service
>
>
>
> : public boost::asio::detail::service_base<serial_port_service>
>
>{
>public:
>
>
>
>
>
>private:
>
>
>
>
> typedef detail::reactive_serial_port_service service_impl_type;
>
>
>public:
>
>
>
>
> typedef service_impl_type::implementation_type implementation_type;
>
>
>
>
>
>
> typedef service_impl_type::native_handle_type native_type;
>
>
>
>
>
>
> typedef service_impl_type::native_handle_type native_handle_type;
>
>
>
> explicit serial_port_service(boost::asio::io_service& io_service)
> : boost::asio::detail::service_base<serial_port_service>(io_service),
> service_impl_(io_service)
> {
> }
>
>
> void construct(implementation_type& impl)
> {
> service_impl_.construct(impl);
> }
>
>
>
> void move_construct(implementation_type& impl,
> implementation_type& other_impl)
> {
> service_impl_.move_construct(impl, other_impl);
> }
>
>
> void move_assign(implementation_type& impl,
> serial_port_service& other_service,
> implementation_type& other_impl)
> {
> service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
> }
>
>
>
> void destroy(implementation_type& impl)
> {
> service_impl_.destroy(impl);
> }
>
>
> boost::system::error_code open(implementation_type& impl,
> const std::string& device, boost::system::error_code& ec)
> {
> return service_impl_.open(impl, device, ec);
> }
>
>
> boost::system::error_code assign(implementation_type& impl,
> const native_handle_type& handle, boost::system::error_code& ec)
> {
> return service_impl_.assign(impl, handle, ec);
> }
>
>
> bool is_open(const implementation_type& impl) const
> {
> return service_impl_.is_open(impl);
> }
>
>
> boost::system::error_code close(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.close(impl, ec);
> }
>
>
> native_type native(implementation_type& impl)
> {
> return service_impl_.native_handle(impl);
> }
>
>
> native_handle_type native_handle(implementation_type& impl)
> {
> return service_impl_.native_handle(impl);
> }
>
>
> boost::system::error_code cancel(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.cancel(impl, ec);
> }
>
>
> template <typename SettableSerialPortOption>
> boost::system::error_code set_option(implementation_type& impl,
> const SettableSerialPortOption& option, boost::system::error_code& ec)
> {
> return service_impl_.set_option(impl, option, ec);
> }
>
>
> template <typename GettableSerialPortOption>
> boost::system::error_code get_option(const implementation_type& impl,
> GettableSerialPortOption& option, boost::system::error_code& ec) const
> {
> return service_impl_.get_option(impl, option, ec);
> }
>
>
> boost::system::error_code send_break(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.send_break(impl, ec);
> }
>
>
> template <typename ConstBufferSequence>
> std::size_t write_some(implementation_type& impl,
> const ConstBufferSequence& buffers, boost::system::error_code& ec)
> {
> return service_impl_.write_some(impl, buffers, ec);
> }
>
>
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_write_some(implementation_type& impl,
> const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
> detail::async_result_init<
> WriteHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<WriteHandler&&>(handler));
>
> service_impl_.async_write_some(impl, buffers, init.handler);
>
> return init.result.get();
> }
>
>
> template <typename MutableBufferSequence>
> std::size_t read_some(implementation_type& impl,
> const MutableBufferSequence& buffers, boost::system::error_code& ec)
> {
> return service_impl_.read_some(impl, buffers, ec);
> }
>
>
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_read_some(implementation_type& impl,
> const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> service_impl_.async_read_some(impl, buffers, init.handler);
>
> return init.result.get();
> }
>
>private:
>
> void shutdown_service()
> {
> service_impl_.shutdown_service();
> }
>
>
> service_impl_type service_impl_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 251 "/usr/include/boost/asio/serial_port_service.hpp" 2 3 4
># 31 "/usr/include/boost/asio/basic_serial_port.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 33 "/usr/include/boost/asio/basic_serial_port.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 46 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
>template <typename SerialPortService = serial_port_service>
>class basic_serial_port
> : public basic_io_object<SerialPortService>,
> public serial_port_base
>{
>public:
>
>
> typedef typename SerialPortService::native_handle_type native_type;
>
>
> typedef typename SerialPortService::native_handle_type native_handle_type;
>
>
> typedef basic_serial_port<SerialPortService> lowest_layer_type;
># 69 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> explicit basic_serial_port(boost::asio::io_service& io_service)
> : basic_io_object<SerialPortService>(io_service)
> {
> }
># 85 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> explicit basic_serial_port(boost::asio::io_service& io_service,
> const char* device)
> : basic_io_object<SerialPortService>(io_service)
> {
> boost::system::error_code ec;
> this->get_service().open(this->get_implementation(), device, ec);
> boost::asio::detail::throw_error(ec, "open");
> }
># 105 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> explicit basic_serial_port(boost::asio::io_service& io_service,
> const std::string& device)
> : basic_io_object<SerialPortService>(io_service)
> {
> boost::system::error_code ec;
> this->get_service().open(this->get_implementation(), device, ec);
> boost::asio::detail::throw_error(ec, "open");
> }
># 126 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> basic_serial_port(boost::asio::io_service& io_service,
> const native_handle_type& native_serial_port)
> : basic_io_object<SerialPortService>(io_service)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> native_serial_port, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 147 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> basic_serial_port(basic_serial_port&& other)
> : basic_io_object<SerialPortService>(
> static_cast<basic_serial_port&&>(other))
> {
> }
># 163 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> basic_serial_port& operator=(basic_serial_port&& other)
> {
> basic_io_object<SerialPortService>::operator=(
> static_cast<basic_serial_port&&>(other));
> return *this;
> }
># 180 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> lowest_layer_type& lowest_layer()
> {
> return *this;
> }
># 194 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> const lowest_layer_type& lowest_layer() const
> {
> return *this;
> }
># 207 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> void open(const std::string& device)
> {
> boost::system::error_code ec;
> this->get_service().open(this->get_implementation(), device, ec);
> boost::asio::detail::throw_error(ec, "open");
> }
># 223 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> boost::system::error_code open(const std::string& device,
> boost::system::error_code& ec)
> {
> return this->get_service().open(this->get_implementation(), device, ec);
> }
># 237 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> void assign(const native_handle_type& native_serial_port)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> native_serial_port, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 253 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> boost::system::error_code assign(const native_handle_type& native_serial_port,
> boost::system::error_code& ec)
> {
> return this->get_service().assign(this->get_implementation(),
> native_serial_port, ec);
> }
>
>
> bool is_open() const
> {
> return this->get_service().is_open(this->get_implementation());
> }
># 274 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> void close()
> {
> boost::system::error_code ec;
> this->get_service().close(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "close");
> }
># 289 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> boost::system::error_code close(boost::system::error_code& ec)
> {
> return this->get_service().close(this->get_implementation(), ec);
> }
># 301 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> native_type native()
> {
> return this->get_service().native_handle(this->get_implementation());
> }
>
>
>
>
>
>
>
> native_handle_type native_handle()
> {
> return this->get_service().native_handle(this->get_implementation());
> }
># 325 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> void cancel()
> {
> boost::system::error_code ec;
> this->get_service().cancel(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "cancel");
> }
># 340 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> boost::system::error_code cancel(boost::system::error_code& ec)
> {
> return this->get_service().cancel(this->get_implementation(), ec);
> }
># 352 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> void send_break()
> {
> boost::system::error_code ec;
> this->get_service().send_break(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "send_break");
> }
># 366 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> boost::system::error_code send_break(boost::system::error_code& ec)
> {
> return this->get_service().send_break(this->get_implementation(), ec);
> }
># 386 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> template <typename SettableSerialPortOption>
> void set_option(const SettableSerialPortOption& option)
> {
> boost::system::error_code ec;
> this->get_service().set_option(this->get_implementation(), option, ec);
> boost::asio::detail::throw_error(ec, "set_option");
> }
># 409 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> template <typename SettableSerialPortOption>
> boost::system::error_code set_option(const SettableSerialPortOption& option,
> boost::system::error_code& ec)
> {
> return this->get_service().set_option(
> this->get_implementation(), option, ec);
> }
># 433 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> template <typename GettableSerialPortOption>
> void get_option(GettableSerialPortOption& option)
> {
> boost::system::error_code ec;
> this->get_service().get_option(this->get_implementation(), option, ec);
> boost::asio::detail::throw_error(ec, "get_option");
> }
># 457 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> template <typename GettableSerialPortOption>
> boost::system::error_code get_option(GettableSerialPortOption& option,
> boost::system::error_code& ec)
> {
> return this->get_service().get_option(
> this->get_implementation(), option, ec);
> }
># 492 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().write_some(
> this->get_implementation(), buffers, ec);
> boost::asio::detail::throw_error(ec, "write_some");
> return s;
> }
># 518 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return this->get_service().write_some(
> this->get_implementation(), buffers, ec);
> }
># 561 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_write_some(const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_write_some(this->get_implementation(),
> buffers, static_cast<WriteHandler&&>(handler));
> }
># 603 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().read_some(
> this->get_implementation(), buffers, ec);
> boost::asio::detail::throw_error(ec, "read_some");
> return s;
> }
># 630 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return this->get_service().read_some(
> this->get_implementation(), buffers, ec);
> }
># 674 "/usr/include/boost/asio/basic_serial_port.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_read_some(const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_read_some(this->get_implementation(),
> buffers, static_cast<ReadHandler&&>(handler));
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 693 "/usr/include/boost/asio/basic_serial_port.hpp" 2 3 4
># 27 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_signal_set.hpp" 1 3 4
># 24 "/usr/include/boost/asio/basic_signal_set.hpp" 3 4
># 1 "/usr/include/boost/asio/signal_set_service.hpp" 1 3 4
># 20 "/usr/include/boost/asio/signal_set_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/signal_set_service.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/signal_set_service.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 21 "/usr/include/boost/asio/detail/signal_set_service.hpp" 2 3 4
># 1 "/usr/include/signal.h" 1 3 4
># 30 "/usr/include/signal.h" 3 4
>extern "C" {
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 102 "/usr/include/bits/sigset.h" 3 4
>extern int __sigismember (const __sigset_t *, int);
>extern int __sigaddset (__sigset_t *, int);
>extern int __sigdelset (__sigset_t *, int);
># 116 "/usr/include/bits/sigset.h" 3 4
>extern __inline __attribute__ ((__gnu_inline__)) int __sigismember (const __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return (__set->__val[__word] & __mask) ? 1 : 0; }
>extern __inline __attribute__ ((__gnu_inline__)) int __sigaddset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] |= __mask), 0); }
>extern __inline __attribute__ ((__gnu_inline__)) int __sigdelset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] &= ~__mask), 0); }
># 33 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>
>
>typedef __sig_atomic_t sig_atomic_t;
>
># 57 "/usr/include/signal.h" 3 4
># 1 "/usr/include/bits/signum.h" 1 3 4
># 58 "/usr/include/signal.h" 2 3 4
># 80 "/usr/include/signal.h" 3 4
># 1 "/usr/include/bits/siginfo.h" 1 3 4
># 24 "/usr/include/bits/siginfo.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 25 "/usr/include/bits/siginfo.h" 2 3 4
># 58 "/usr/include/bits/siginfo.h" 3 4
>typedef __clock_t __sigchld_clock_t;
>
>
>
>typedef struct
> {
> int si_signo;
> int si_errno;
>
> int si_code;
>
> union
> {
> int _pad[((128 / sizeof (int)) - 4)];
>
>
> struct
> {
> __pid_t si_pid;
> __uid_t si_uid;
> } _kill;
>
>
> struct
> {
> int si_tid;
> int si_overrun;
> sigval_t si_sigval;
> } _timer;
>
>
> struct
> {
> __pid_t si_pid;
> __uid_t si_uid;
> sigval_t si_sigval;
> } _rt;
>
>
> struct
> {
> __pid_t si_pid;
> __uid_t si_uid;
> int si_status;
> __sigchld_clock_t si_utime;
> __sigchld_clock_t si_stime;
> } _sigchld;
>
>
> struct
> {
> void *si_addr;
> short int si_addr_lsb;
> } _sigfault;
>
>
> struct
> {
> long int si_band;
> int si_fd;
> } _sigpoll;
>
>
> struct
> {
> void *_call_addr;
> int _syscall;
> unsigned int _arch;
> } _sigsys;
> } _sifields;
> } siginfo_t ;
># 153 "/usr/include/bits/siginfo.h" 3 4
>enum
>{
> SI_ASYNCNL = -60,
>
> SI_TKILL = -6,
>
> SI_SIGIO,
>
> SI_ASYNCIO,
>
> SI_MESGQ,
>
> SI_TIMER,
>
> SI_QUEUE,
>
> SI_USER,
>
> SI_KERNEL = 0x80
>
>};
>
>
>
>enum
>{
> ILL_ILLOPC = 1,
>
> ILL_ILLOPN,
>
> ILL_ILLADR,
>
> ILL_ILLTRP,
>
> ILL_PRVOPC,
>
> ILL_PRVREG,
>
> ILL_COPROC,
>
> ILL_BADSTK
>
>};
>
>
>enum
>{
> FPE_INTDIV = 1,
>
> FPE_INTOVF,
>
> FPE_FLTDIV,
>
> FPE_FLTOVF,
>
> FPE_FLTUND,
>
> FPE_FLTRES,
>
> FPE_FLTINV,
>
> FPE_FLTSUB
>
>};
>
>
>enum
>{
> SEGV_MAPERR = 1,
>
> SEGV_ACCERR
>
>};
>
>
>enum
>{
> BUS_ADRALN = 1,
>
> BUS_ADRERR,
>
> BUS_OBJERR,
>
> BUS_MCEERR_AR,
>
> BUS_MCEERR_AO
>
>};
>
>
>enum
>{
> TRAP_BRKPT = 1,
>
> TRAP_TRACE
>
>};
>
>
>enum
>{
> CLD_EXITED = 1,
>
> CLD_KILLED,
>
> CLD_DUMPED,
>
> CLD_TRAPPED,
>
> CLD_STOPPED,
>
> CLD_CONTINUED
>
>};
>
>
>enum
>{
> POLL_IN = 1,
>
> POLL_OUT,
>
> POLL_MSG,
>
> POLL_ERR,
>
> POLL_PRI,
>
> POLL_HUP
>
>};
># 81 "/usr/include/signal.h" 2 3 4
>
>
>
>
>typedef void (*__sighandler_t) (int);
>
>
>
>
>extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
> throw ();
>
>extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
> throw ();
>
>
>
>
>
>
>
>extern __sighandler_t signal (int __sig, __sighandler_t __handler)
> throw ();
># 114 "/usr/include/signal.h" 3 4
>
>
>
>
>
>extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler)
> throw ();
>
>
>
>
>
>
>extern int kill (__pid_t __pid, int __sig) throw ();
>
>
>
>
>
>
>extern int killpg (__pid_t __pgrp, int __sig) throw ();
>
>
>
>
>extern int raise (int __sig) throw ();
>
>
>
>
>extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
> throw ();
>extern int gsignal (int __sig) throw ();
>
>
>
>
>extern void psignal (int __sig, const char *__s);
>
>
>
>
>extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
># 169 "/usr/include/signal.h" 3 4
>extern int __sigpause (int __sig_or_mask, int __is_sig);
># 178 "/usr/include/signal.h" 3 4
>extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
># 197 "/usr/include/signal.h" 3 4
>extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));
>
>
>extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));
>
>
>extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
># 212 "/usr/include/signal.h" 3 4
>typedef __sighandler_t sighandler_t;
>
>
>
>
>typedef __sighandler_t sig_t;
>
>
>
>
>
>extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigismember (const sigset_t *__set, int __signo)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int sigisemptyset (const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigandset (sigset_t *__set, const sigset_t *__left,
> const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>extern int sigorset (sigset_t *__set, const sigset_t *__left,
> const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
># 1 "/usr/include/bits/sigaction.h" 1 3 4
># 24 "/usr/include/bits/sigaction.h" 3 4
>struct sigaction
> {
>
>
> union
> {
>
> __sighandler_t sa_handler;
>
> void (*sa_sigaction) (int, siginfo_t *, void *);
> }
> __sigaction_handler;
>
>
>
>
>
>
>
> __sigset_t sa_mask;
>
>
> int sa_flags;
>
>
> void (*sa_restorer) (void);
> };
># 254 "/usr/include/signal.h" 2 3 4
>
>
>extern int sigprocmask (int __how, const sigset_t *__restrict __set,
> sigset_t *__restrict __oset) throw ();
>
>
>
>
>
>
>extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigaction (int __sig, const struct sigaction *__restrict __act,
> struct sigaction *__restrict __oact) throw ();
>
>
>extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
> __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int sigwaitinfo (const sigset_t *__restrict __set,
> siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sigtimedwait (const sigset_t *__restrict __set,
> siginfo_t *__restrict __info,
> const struct timespec *__restrict __timeout)
> __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
> throw ();
># 311 "/usr/include/signal.h" 3 4
>extern const char *const _sys_siglist[65];
>extern const char *const sys_siglist[65];
>
>
>struct sigvec
> {
> __sighandler_t sv_handler;
> int sv_mask;
>
> int sv_flags;
>
> };
># 335 "/usr/include/signal.h" 3 4
>extern int sigvec (int __sig, const struct sigvec *__vec,
> struct sigvec *__ovec) throw ();
>
>
>
># 1 "/usr/include/bits/sigcontext.h" 1 3 4
># 29 "/usr/include/bits/sigcontext.h" 3 4
>struct _fpx_sw_bytes
>{
> __uint32_t magic1;
> __uint32_t extended_size;
> __uint64_t xstate_bv;
> __uint32_t xstate_size;
> __uint32_t padding[7];
>};
>
>struct _fpreg
>{
> unsigned short significand[4];
> unsigned short exponent;
>};
>
>struct _fpxreg
>{
> unsigned short significand[4];
> unsigned short exponent;
> unsigned short padding[3];
>};
>
>struct _xmmreg
>{
> __uint32_t element[4];
>};
># 121 "/usr/include/bits/sigcontext.h" 3 4
>struct _fpstate
>{
>
> __uint16_t cwd;
> __uint16_t swd;
> __uint16_t ftw;
> __uint16_t fop;
> __uint64_t rip;
> __uint64_t rdp;
> __uint32_t mxcsr;
> __uint32_t mxcr_mask;
> struct _fpxreg _st[8];
> struct _xmmreg _xmm[16];
> __uint32_t padding[24];
>};
>
>struct sigcontext
>{
> __uint64_t r8;
> __uint64_t r9;
> __uint64_t r10;
> __uint64_t r11;
> __uint64_t r12;
> __uint64_t r13;
> __uint64_t r14;
> __uint64_t r15;
> __uint64_t rdi;
> __uint64_t rsi;
> __uint64_t rbp;
> __uint64_t rbx;
> __uint64_t rdx;
> __uint64_t rax;
> __uint64_t rcx;
> __uint64_t rsp;
> __uint64_t rip;
> __uint64_t eflags;
> unsigned short cs;
> unsigned short gs;
> unsigned short fs;
> unsigned short __pad0;
> __uint64_t err;
> __uint64_t trapno;
> __uint64_t oldmask;
> __uint64_t cr2;
> __extension__ union
> {
> struct _fpstate * fpstate;
> __uint64_t __fpstate_word;
> };
> __uint64_t __reserved1 [8];
>};
>
>
>
>struct _xsave_hdr
>{
> __uint64_t xstate_bv;
> __uint64_t reserved1[2];
> __uint64_t reserved2[5];
>};
>
>struct _ymmh_state
>{
> __uint32_t ymmh_space[64];
>};
>
>struct _xstate
>{
> struct _fpstate fpstate;
> struct _xsave_hdr xstate_hdr;
> struct _ymmh_state ymmh;
>};
># 341 "/usr/include/signal.h" 2 3 4
>
>
>extern int sigreturn (struct sigcontext *__scp) throw ();
>
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 351 "/usr/include/signal.h" 2 3 4
>
>
>
>
>extern int siginterrupt (int __sig, int __interrupt) throw ();
>
># 1 "/usr/include/bits/sigstack.h" 1 3 4
># 25 "/usr/include/bits/sigstack.h" 3 4
>struct sigstack
> {
> void *ss_sp;
> int ss_onstack;
> };
>
>
>
>enum
>{
> SS_ONSTACK = 1,
>
> SS_DISABLE
>
>};
># 49 "/usr/include/bits/sigstack.h" 3 4
>typedef struct sigaltstack
> {
> void *ss_sp;
> int ss_flags;
> size_t ss_size;
> } stack_t;
># 358 "/usr/include/signal.h" 2 3 4
>
>
># 1 "/usr/include/sys/ucontext.h" 1 3 4
># 22 "/usr/include/sys/ucontext.h" 3 4
># 1 "/usr/include/signal.h" 1 3 4
># 23 "/usr/include/sys/ucontext.h" 2 3 4
># 31 "/usr/include/sys/ucontext.h" 3 4
>__extension__ typedef long long int greg_t;
>
>
>
>
>
>typedef greg_t gregset_t[23];
>
>
>
>enum
>{
> REG_R8 = 0,
>
> REG_R9,
>
> REG_R10,
>
> REG_R11,
>
> REG_R12,
>
> REG_R13,
>
> REG_R14,
>
> REG_R15,
>
> REG_RDI,
>
> REG_RSI,
>
> REG_RBP,
>
> REG_RBX,
>
> REG_RDX,
>
> REG_RAX,
>
> REG_RCX,
>
> REG_RSP,
>
> REG_RIP,
>
> REG_EFL,
>
> REG_CSGSFS,
>
> REG_ERR,
>
> REG_TRAPNO,
>
> REG_OLDMASK,
>
> REG_CR2
>
>};
>
>
>struct _libc_fpxreg
>{
> unsigned short int significand[4];
> unsigned short int exponent;
> unsigned short int padding[3];
>};
>
>struct _libc_xmmreg
>{
> __uint32_t element[4];
>};
>
>struct _libc_fpstate
>{
>
> __uint16_t cwd;
> __uint16_t swd;
> __uint16_t ftw;
> __uint16_t fop;
> __uint64_t rip;
> __uint64_t rdp;
> __uint32_t mxcsr;
> __uint32_t mxcr_mask;
> struct _libc_fpxreg _st[8];
> struct _libc_xmmreg _xmm[16];
> __uint32_t padding[24];
>};
>
>
>typedef struct _libc_fpstate *fpregset_t;
>
>
>typedef struct
> {
> gregset_t gregs;
>
> fpregset_t fpregs;
> __extension__ unsigned long long __reserved1 [8];
>} mcontext_t;
>
>
>typedef struct ucontext
> {
> unsigned long int uc_flags;
> struct ucontext *uc_link;
> stack_t uc_stack;
> mcontext_t uc_mcontext;
> __sigset_t uc_sigmask;
> struct _libc_fpstate __fpregs_mem;
> } ucontext_t;
># 361 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
> throw () __attribute__ ((__deprecated__));
>
>
>
>extern int sigaltstack (const struct sigaltstack *__restrict __ss,
> struct sigaltstack *__restrict __oss) throw ();
>
>
>
>
>
>
>
>extern int sighold (int __sig) throw ();
>
>
>extern int sigrelse (int __sig) throw ();
>
>
>extern int sigignore (int __sig) throw ();
>
>
>extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();
>
>
>
>
>
>
># 1 "/usr/include/bits/sigthread.h" 1 3 4
># 30 "/usr/include/bits/sigthread.h" 3 4
>extern int pthread_sigmask (int __how,
> const __sigset_t *__restrict __newmask,
> __sigset_t *__restrict __oldmask)throw ();
>
>
>extern int pthread_kill (pthread_t __threadid, int __signo) throw ();
>
>
>
>extern int pthread_sigqueue (pthread_t __threadid, int __signo,
> const union sigval __value) throw ();
># 397 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>
>extern int __libc_current_sigrtmin (void) throw ();
>
>extern int __libc_current_sigrtmax (void) throw ();
>
>
>
>}
># 22 "/usr/include/boost/asio/detail/signal_set_service.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/signal_handler.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/signal_handler.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/signal_op.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/signal_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/signal_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class signal_op
> : public operation
>{
>public:
>
> boost::system::error_code ec_;
>
>
> int signal_number_;
>
>protected:
> signal_op(func_type func)
> : operation(func),
> signal_number_(0)
> {
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 50 "/usr/include/boost/asio/detail/signal_op.hpp" 2 3 4
># 24 "/usr/include/boost/asio/detail/signal_handler.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/signal_handler.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Handler>
>class signal_handler : public signal_op
>{
>public:
> struct ptr { Handler* h; void* v; signal_handler* p; ~ptr() { reset(); } void reset() { if (p) { p->~signal_handler(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(signal_handler), *h); v = 0; } } };
>
> signal_handler(Handler& h)
> : signal_op(&signal_handler::do_complete),
> handler_(static_cast<Handler&&>(h))
> {
> }
>
> static void do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> signal_handler* h(static_cast<signal_handler*>(base));
> ptr p = { boost::asio::detail::addressof(h->handler_), h, h };
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, int>
> handler(h->handler_, h->ec_, h->signal_number_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 83 "/usr/include/boost/asio/detail/signal_handler.hpp" 2 3 4
># 28 "/usr/include/boost/asio/detail/signal_set_service.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 36 "/usr/include/boost/asio/detail/signal_set_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>enum { max_signal_number = 65 };
>
>
>
>
>extern inline struct signal_state* get_signal_state();
>
>extern "C" inline void asio_signal_handler(int signal_number);
>
>class signal_set_service
>{
>public:
>
> class registration
> {
> public:
>
> registration()
> : signal_number_(0),
> queue_(0),
> undelivered_(0),
> next_in_table_(0),
> prev_in_table_(0),
> next_in_set_(0)
> {
> }
>
> private:
>
> friend class signal_set_service;
>
>
> int signal_number_;
>
>
> op_queue<signal_op>* queue_;
>
>
> std::size_t undelivered_;
>
>
> registration* next_in_table_;
> registration* prev_in_table_;
>
>
> registration* next_in_set_;
> };
>
>
> class implementation_type
> {
> public:
>
> implementation_type()
> : signals_(0)
> {
> }
>
> private:
>
> friend class signal_set_service;
>
>
> op_queue<signal_op> queue_;
>
>
> registration* signals_;
> };
>
>
> inline signal_set_service(boost::asio::io_service& io_service);
>
>
> inline ~signal_set_service();
>
>
> inline void shutdown_service();
>
>
> inline void fork_service(
> boost::asio::io_service::fork_event fork_ev);
>
>
> inline void construct(implementation_type& impl);
>
>
> inline void destroy(implementation_type& impl);
>
>
> inline boost::system::error_code add(implementation_type& impl,
> int signal_number, boost::system::error_code& ec);
>
>
> inline boost::system::error_code remove(implementation_type& impl,
> int signal_number, boost::system::error_code& ec);
>
>
> inline boost::system::error_code clear(implementation_type& impl,
> boost::system::error_code& ec);
>
>
> inline boost::system::error_code cancel(implementation_type& impl,
> boost::system::error_code& ec);
>
>
> template <typename Handler>
> void async_wait(implementation_type& impl, Handler& handler)
> {
>
> typedef signal_handler<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0;
>
> start_wait_op(impl, p.p);
> p.v = p.p = 0;
> }
>
>
> inline static void deliver_signal(int signal_number);
>
>private:
>
> inline static void add_service(signal_set_service* service);
>
>
> inline static void remove_service(signal_set_service* service);
>
>
> inline static void open_descriptors();
>
>
> inline static void close_descriptors();
>
>
> inline void start_wait_op(implementation_type& impl, signal_op* op);
>
>
> io_service_impl& io_service_;
>
>
>
> class pipe_read_op;
>
>
> reactor& reactor_;
>
>
> reactor::per_descriptor_data reactor_data_;
>
>
>
> registration* registrations_[max_signal_number];
>
>
> signal_set_service* next_;
> signal_set_service* prev_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 209 "/usr/include/boost/asio/detail/signal_set_service.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 21 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/signal_blocker.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/signal_blocker.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_signal_blocker.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/posix_signal_blocker.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/csignal" 1 3 4
># 39 "/usr/include/c++/4.8.2/csignal" 3 4
> 
># 40 "/usr/include/c++/4.8.2/csignal" 3
># 50 "/usr/include/c++/4.8.2/csignal" 3
>namespace std
>{
> using ::sig_atomic_t;
> using ::signal;
> using ::raise;
>}
># 23 "/usr/include/boost/asio/detail/posix_signal_blocker.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/detail/posix_signal_blocker.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class posix_signal_blocker
> : private noncopyable
>{
>public:
>
> posix_signal_blocker()
> : blocked_(false)
> {
> sigset_t new_mask;
> sigfillset(&new_mask);
> blocked_ = (pthread_sigmask(0, &new_mask, &old_mask_) == 0);
> }
>
>
> ~posix_signal_blocker()
> {
> if (blocked_)
> pthread_sigmask(2, &old_mask_, 0);
> }
>
>
> void block()
> {
> if (!blocked_)
> {
> sigset_t new_mask;
> sigfillset(&new_mask);
> blocked_ = (pthread_sigmask(0, &new_mask, &old_mask_) == 0);
> }
> }
>
>
> void unblock()
> {
> if (blocked_)
> blocked_ = (pthread_sigmask(2, &old_mask_, 0) != 0);
> }
>
>private:
>
> bool blocked_;
>
>
> sigset_t old_mask_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 84 "/usr/include/boost/asio/detail/posix_signal_blocker.hpp" 2 3 4
># 25 "/usr/include/boost/asio/detail/signal_blocker.hpp" 2 3 4
>
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>
>typedef posix_signal_blocker signal_blocker;
>
>
>}
>}
>}
># 23 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/signal_set_service.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/static_mutex.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/static_mutex.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_static_mutex.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/posix_static_mutex.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/posix_static_mutex.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>struct posix_static_mutex
>{
> typedef boost::asio::detail::scoped_lock<posix_static_mutex> scoped_lock;
>
>
> void init()
> {
>
> }
>
>
> void lock()
> {
> (void)::pthread_mutex_lock(&mutex_);
> }
>
>
> void unlock()
> {
> (void)::pthread_mutex_unlock(&mutex_);
> }
>
> ::pthread_mutex_t mutex_;
>};
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 63 "/usr/include/boost/asio/detail/posix_static_mutex.hpp" 2 3 4
># 26 "/usr/include/boost/asio/detail/static_mutex.hpp" 2 3 4
>
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
># 41 "/usr/include/boost/asio/detail/static_mutex.hpp" 3 4
>typedef posix_static_mutex static_mutex;
>
>
>
>}
>}
>}
># 25 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>struct signal_state
>{
>
> static_mutex mutex_;
>
>
> int read_descriptor_;
>
>
> int write_descriptor_;
>
>
> bool fork_prepared_;
>
>
> class signal_set_service* service_list_;
>
>
> std::size_t registration_count_[max_signal_number];
>};
>
>signal_state* get_signal_state()
>{
> static signal_state state = {
> { { { 0, 0, 0, 0, 0, 0, 0, { 0, 0 } } } }, -1, -1, false, 0, { 0 } };
> return &state;
>}
>
>void asio_signal_handler(int signal_number)
>{
>
>
>
> int saved_errno = (*__errno_location ());
> signal_state* state = get_signal_state();
> signed_size_type result = ::write(state->write_descriptor_,
> &signal_number, sizeof(signal_number));
> (void)result;
> (*__errno_location ()) = saved_errno;
>
>
>
>
>
>}
>
>
>class signal_set_service::pipe_read_op : public reactor_op
>{
>public:
> pipe_read_op()
> : reactor_op(&pipe_read_op::do_perform, pipe_read_op::do_complete)
> {
> }
>
> static bool do_perform(reactor_op*)
> {
> signal_state* state = get_signal_state();
>
> int fd = state->read_descriptor_;
> int signal_number = 0;
> while (::read(fd, &signal_number, sizeof(int)) == sizeof(int))
> if (signal_number >= 0 && signal_number < max_signal_number)
> signal_set_service::deliver_signal(signal_number);
>
> return false;
> }
>
> static void do_complete(io_service_impl* , operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
> pipe_read_op* o(static_cast<pipe_read_op*>(base));
> delete o;
> }
>};
>
>
>signal_set_service::signal_set_service(
> boost::asio::io_service& io_service)
> : io_service_(boost::asio::use_service<io_service_impl>(io_service)),
>
> reactor_(boost::asio::use_service<reactor>(io_service)),
>
> next_(0),
> prev_(0)
>{
> get_signal_state()->mutex_.init();
>
>
> reactor_.init_task();
>
>
> for (int i = 0; i < max_signal_number; ++i)
> registrations_[i] = 0;
>
> add_service(this);
>}
>
>signal_set_service::~signal_set_service()
>{
> remove_service(this);
>}
>
>void signal_set_service::shutdown_service()
>{
> remove_service(this);
>
> op_queue<operation> ops;
>
> for (int i = 0; i < max_signal_number; ++i)
> {
> registration* reg = registrations_[i];
> while (reg)
> {
> ops.push(*reg->queue_);
> reg = reg->next_in_table_;
> }
> }
>
> io_service_.abandon_operations(ops);
>}
>
>void signal_set_service::fork_service(
> boost::asio::io_service::fork_event fork_ev)
>{
>
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
> switch (fork_ev)
> {
> case boost::asio::io_service::fork_prepare:
> {
> int read_descriptor = state->read_descriptor_;
> state->fork_prepared_ = true;
> lock.unlock();
> reactor_.deregister_internal_descriptor(read_descriptor, reactor_data_);
> }
> break;
> case boost::asio::io_service::fork_parent:
> if (state->fork_prepared_)
> {
> int read_descriptor = state->read_descriptor_;
> state->fork_prepared_ = false;
> lock.unlock();
> reactor_.register_internal_descriptor(reactor::read_op,
> read_descriptor, reactor_data_, new pipe_read_op);
> }
> break;
> case boost::asio::io_service::fork_child:
> if (state->fork_prepared_)
> {
> boost::asio::detail::signal_blocker blocker;
> close_descriptors();
> open_descriptors();
> int read_descriptor = state->read_descriptor_;
> state->fork_prepared_ = false;
> lock.unlock();
> reactor_.register_internal_descriptor(reactor::read_op,
> read_descriptor, reactor_data_, new pipe_read_op);
> }
> break;
> default:
> break;
> }
>
>
>
>}
>
>void signal_set_service::construct(
> signal_set_service::implementation_type& impl)
>{
> impl.signals_ = 0;
>}
>
>void signal_set_service::destroy(
> signal_set_service::implementation_type& impl)
>{
> boost::system::error_code ignored_ec;
> clear(impl, ignored_ec);
> cancel(impl, ignored_ec);
>}
>
>boost::system::error_code signal_set_service::add(
> signal_set_service::implementation_type& impl,
> int signal_number, boost::system::error_code& ec)
>{
>
> if (signal_number < 0 || signal_number > max_signal_number)
> {
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
>
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
>
> registration** insertion_point = &impl.signals_;
> registration* next = impl.signals_;
> while (next && next->signal_number_ < signal_number)
> {
> insertion_point = &next->next_in_set_;
> next = next->next_in_set_;
> }
>
>
> if (next == 0 || next->signal_number_ != signal_number)
> {
> registration* new_registration = new registration;
>
>
>
> if (state->registration_count_[signal_number] == 0)
> {
>
> using namespace std;
> struct sigaction sa;
> memset(&sa, 0, sizeof(sa));
> sa.__sigaction_handler.sa_handler = asio_signal_handler;
> sigfillset(&sa.sa_mask);
> if (::sigaction(signal_number, &sa, 0) == -1)
>
>
>
> {
>
>
>
> ec = boost::system::error_code((*__errno_location ()),
> boost::asio::error::get_system_category());
>
> delete new_registration;
> return ec;
> }
> }
>
>
>
> new_registration->signal_number_ = signal_number;
> new_registration->queue_ = &impl.queue_;
> new_registration->next_in_set_ = next;
> *insertion_point = new_registration;
>
>
> new_registration->next_in_table_ = registrations_[signal_number];
> if (registrations_[signal_number])
> registrations_[signal_number]->prev_in_table_ = new_registration;
> registrations_[signal_number] = new_registration;
>
> ++state->registration_count_[signal_number];
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code signal_set_service::remove(
> signal_set_service::implementation_type& impl,
> int signal_number, boost::system::error_code& ec)
>{
>
> if (signal_number < 0 || signal_number > max_signal_number)
> {
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
>
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
>
> registration** deletion_point = &impl.signals_;
> registration* reg = impl.signals_;
> while (reg && reg->signal_number_ < signal_number)
> {
> deletion_point = &reg->next_in_set_;
> reg = reg->next_in_set_;
> }
>
> if (reg != 0 && reg->signal_number_ == signal_number)
> {
>
>
> if (state->registration_count_[signal_number] == 1)
> {
>
> using namespace std;
> struct sigaction sa;
> memset(&sa, 0, sizeof(sa));
> sa.__sigaction_handler.sa_handler = ((__sighandler_t) 0);
> if (::sigaction(signal_number, &sa, 0) == -1)
>
>
>
> {
>
>
>
> ec = boost::system::error_code((*__errno_location ()),
> boost::asio::error::get_system_category());
>
> return ec;
> }
> }
>
>
>
> *deletion_point = reg->next_in_set_;
>
>
> if (registrations_[signal_number] == reg)
> registrations_[signal_number] = reg->next_in_table_;
> if (reg->prev_in_table_)
> reg->prev_in_table_->next_in_table_ = reg->next_in_table_;
> if (reg->next_in_table_)
> reg->next_in_table_->prev_in_table_ = reg->prev_in_table_;
>
> --state->registration_count_[signal_number];
>
> delete reg;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code signal_set_service::clear(
> signal_set_service::implementation_type& impl,
> boost::system::error_code& ec)
>{
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
> while (registration* reg = impl.signals_)
> {
>
>
> if (state->registration_count_[reg->signal_number_] == 1)
> {
>
> using namespace std;
> struct sigaction sa;
> memset(&sa, 0, sizeof(sa));
> sa.__sigaction_handler.sa_handler = ((__sighandler_t) 0);
> if (::sigaction(reg->signal_number_, &sa, 0) == -1)
>
>
>
> {
>
>
>
> ec = boost::system::error_code((*__errno_location ()),
> boost::asio::error::get_system_category());
>
> return ec;
> }
> }
>
>
>
> if (registrations_[reg->signal_number_] == reg)
> registrations_[reg->signal_number_] = reg->next_in_table_;
> if (reg->prev_in_table_)
> reg->prev_in_table_->next_in_table_ = reg->next_in_table_;
> if (reg->next_in_table_)
> reg->next_in_table_->prev_in_table_ = reg->prev_in_table_;
>
> --state->registration_count_[reg->signal_number_];
>
> impl.signals_ = reg->next_in_set_;
> delete reg;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code signal_set_service::cancel(
> signal_set_service::implementation_type& impl,
> boost::system::error_code& ec)
>{
> (void)0;
>
> op_queue<operation> ops;
> {
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
> while (signal_op* op = impl.queue_.front())
> {
> op->ec_ = boost::asio::error::operation_aborted;
> impl.queue_.pop();
> ops.push(op);
> }
> }
>
> io_service_.post_deferred_completions(ops);
>
> ec = boost::system::error_code();
> return ec;
>}
>
>void signal_set_service::deliver_signal(int signal_number)
>{
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
> signal_set_service* service = state->service_list_;
> while (service)
> {
> op_queue<operation> ops;
>
> registration* reg = service->registrations_[signal_number];
> while (reg)
> {
> if (reg->queue_->empty())
> {
> ++reg->undelivered_;
> }
> else
> {
> while (signal_op* op = reg->queue_->front())
> {
> op->signal_number_ = signal_number;
> reg->queue_->pop();
> ops.push(op);
> }
> }
>
> reg = reg->next_in_table_;
> }
>
> service->io_service_.post_deferred_completions(ops);
>
> service = service->next_;
> }
>}
>
>void signal_set_service::add_service(signal_set_service* service)
>{
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
>
>
> if (state->service_list_ == 0)
> open_descriptors();
>
>
>
> service->next_ = state->service_list_;
> service->prev_ = 0;
> if (state->service_list_)
> state->service_list_->prev_ = service;
> state->service_list_ = service;
>
>
>
> int read_descriptor = state->read_descriptor_;
> lock.unlock();
> service->reactor_.register_internal_descriptor(reactor::read_op,
> read_descriptor, service->reactor_data_, new pipe_read_op);
>
>}
>
>void signal_set_service::remove_service(signal_set_service* service)
>{
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
> if (service->next_ || service->prev_ || state->service_list_ == service)
> {
>
>
> int read_descriptor = state->read_descriptor_;
> lock.unlock();
> service->reactor_.deregister_descriptor(
> read_descriptor, service->reactor_data_, false);
> lock.lock();
>
>
>
> if (state->service_list_ == service)
> state->service_list_ = service->next_;
> if (service->prev_)
> service->prev_->next_ = service->next_;
> if (service->next_)
> service->next_->prev_= service->prev_;
> service->next_ = 0;
> service->prev_ = 0;
>
>
>
> if (state->service_list_ == 0)
> close_descriptors();
>
> }
>}
>
>void signal_set_service::open_descriptors()
>{
>
> signal_state* state = get_signal_state();
>
> int pipe_fds[2];
> if (::pipe(pipe_fds) == 0)
> {
> state->read_descriptor_ = pipe_fds[0];
> ::fcntl(state->read_descriptor_, 4, 04000);
>
> state->write_descriptor_ = pipe_fds[1];
> ::fcntl(state->write_descriptor_, 4, 04000);
>
>
> ::fcntl(state->read_descriptor_, 2, 1);
> ::fcntl(state->write_descriptor_, 2, 1);
>
> }
> else
> {
> boost::system::error_code ec((*__errno_location ()),
> boost::asio::error::get_system_category());
> boost::asio::detail::throw_error(ec, "signal_set_service pipe");
> }
>
>}
>
>void signal_set_service::close_descriptors()
>{
>
> signal_state* state = get_signal_state();
>
> if (state->read_descriptor_ != -1)
> ::close(state->read_descriptor_);
> state->read_descriptor_ = -1;
>
> if (state->write_descriptor_ != -1)
> ::close(state->write_descriptor_);
> state->write_descriptor_ = -1;
>
>}
>
>void signal_set_service::start_wait_op(
> signal_set_service::implementation_type& impl, signal_op* op)
>{
> io_service_.work_started();
>
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
> registration* reg = impl.signals_;
> while (reg)
> {
> if (reg->undelivered_ > 0)
> {
> --reg->undelivered_;
> io_service_.post_deferred_completion(op);
> return;
> }
>
> reg = reg->next_in_set_;
> }
>
> impl.queue_.push(op);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 607 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4
># 212 "/usr/include/boost/asio/detail/signal_set_service.hpp" 2 3 4
># 21 "/usr/include/boost/asio/signal_set_service.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 25 "/usr/include/boost/asio/signal_set_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>class signal_set_service
>
>
>
> : public boost::asio::detail::service_base<signal_set_service>
>
>{
>public:
>
>
>
>
>
>public:
>
>
>
>
> typedef detail::signal_set_service::implementation_type implementation_type;
>
>
>
> explicit signal_set_service(boost::asio::io_service& io_service)
> : boost::asio::detail::service_base<signal_set_service>(io_service),
> service_impl_(io_service)
> {
> }
>
>
> void construct(implementation_type& impl)
> {
> service_impl_.construct(impl);
> }
>
>
> void destroy(implementation_type& impl)
> {
> service_impl_.destroy(impl);
> }
>
>
> boost::system::error_code add(implementation_type& impl,
> int signal_number, boost::system::error_code& ec)
> {
> return service_impl_.add(impl, signal_number, ec);
> }
>
>
> boost::system::error_code remove(implementation_type& impl,
> int signal_number, boost::system::error_code& ec)
> {
> return service_impl_.remove(impl, signal_number, ec);
> }
>
>
> boost::system::error_code clear(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.clear(impl, ec);
> }
>
>
> boost::system::error_code cancel(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.cancel(impl, ec);
> }
>
>
> template <typename SignalHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<SignalHandler, void (boost::system::error_code, int)>::type>::type
>
> async_wait(implementation_type& impl,
> SignalHandler&& handler)
> {
> detail::async_result_init<
> SignalHandler, void (boost::system::error_code, int)> init(
> static_cast<SignalHandler&&>(handler));
>
> service_impl_.async_wait(impl, init.handler);
>
> return init.result.get();
> }
>
>private:
>
> void shutdown_service()
> {
> service_impl_.shutdown_service();
> }
>
>
> void fork_service(boost::asio::io_service::fork_event event)
> {
> service_impl_.fork_service(event);
> }
>
>
> detail::signal_set_service service_impl_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 135 "/usr/include/boost/asio/signal_set_service.hpp" 2 3 4
># 25 "/usr/include/boost/asio/basic_signal_set.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/basic_signal_set.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 93 "/usr/include/boost/asio/basic_signal_set.hpp" 3 4
>template <typename SignalSetService = signal_set_service>
>class basic_signal_set
> : public basic_io_object<SignalSetService>
>{
>public:
>
>
>
>
>
>
>
> explicit basic_signal_set(boost::asio::io_service& io_service)
> : basic_io_object<SignalSetService>(io_service)
> {
> }
># 123 "/usr/include/boost/asio/basic_signal_set.hpp" 3 4
> basic_signal_set(boost::asio::io_service& io_service, int signal_number_1)
> : basic_io_object<SignalSetService>(io_service)
> {
> boost::system::error_code ec;
> this->service.add(this->implementation, signal_number_1, ec);
> boost::asio::detail::throw_error(ec, "add");
> }
># 147 "/usr/include/boost/asio/basic_signal_set.hpp" 3 4
> basic_signal_set(boost::asio::io_service& io_service, int signal_number_1,
> int signal_number_2)
> : basic_io_object<SignalSetService>(io_service)
> {
> boost::system::error_code ec;
> this->service.add(this->implementation, signal_number_1, ec);
> boost::asio::detail::throw_error(ec, "add");
> this->service.add(this->implementation, signal_number_2, ec);
> boost::asio::detail::throw_error(ec, "add");
> }
># 177 "/usr/include/boost/asio/basic_signal_set.hpp" 3 4
> basic_signal_set(boost::asio::io_service& io_service, int signal_number_1,
> int signal_number_2, int signal_number_3)
> : basic_io_object<SignalSetService>(io_service)
> {
> boost::system::error_code ec;
> this->service.add(this->implementation, signal_number_1, ec);
> boost::asio::detail::throw_error(ec, "add");
> this->service.add(this->implementation, signal_number_2, ec);
> boost::asio::detail::throw_error(ec, "add");
> this->service.add(this->implementation, signal_number_3, ec);
> boost::asio::detail::throw_error(ec, "add");
> }
># 199 "/usr/include/boost/asio/basic_signal_set.hpp" 3 4
> void add(int signal_number)
> {
> boost::system::error_code ec;
> this->service.add(this->implementation, signal_number, ec);
> boost::asio::detail::throw_error(ec, "add");
> }
># 215 "/usr/include/boost/asio/basic_signal_set.hpp" 3 4
> boost::system::error_code add(int signal_number,
> boost::system::error_code& ec)
> {
> return this->service.add(this->implementation, signal_number, ec);
> }
># 233 "/usr/include/boost/asio/basic_signal_set.hpp" 3 4
> void remove(int signal_number)
> {
> boost::system::error_code ec;
> this->service.remove(this->implementation, signal_number, ec);
> boost::asio::detail::throw_error(ec, "remove");
> }
># 252 "/usr/include/boost/asio/basic_signal_set.hpp" 3 4
> boost::system::error_code remove(int signal_number,
> boost::system::error_code& ec)
> {
> return this->service.remove(this->implementation, signal_number, ec);
> }
># 267 "/usr/include/boost/asio/basic_signal_set.hpp" 3 4
> void clear()
> {
> boost::system::error_code ec;
> this->service.clear(this->implementation, ec);
> boost::asio::detail::throw_error(ec, "clear");
> }
># 283 "/usr/include/boost/asio/basic_signal_set.hpp" 3 4
> boost::system::error_code clear(boost::system::error_code& ec)
> {
> return this->service.clear(this->implementation, ec);
> }
># 309 "/usr/include/boost/asio/basic_signal_set.hpp" 3 4
> void cancel()
> {
> boost::system::error_code ec;
> this->service.cancel(this->implementation, ec);
> boost::asio::detail::throw_error(ec, "cancel");
> }
># 337 "/usr/include/boost/asio/basic_signal_set.hpp" 3 4
> boost::system::error_code cancel(boost::system::error_code& ec)
> {
> return this->service.cancel(this->implementation, ec);
> }
># 367 "/usr/include/boost/asio/basic_signal_set.hpp" 3 4
> template <typename SignalHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<SignalHandler, void (boost::system::error_code, int)>::type>::type
>
> async_wait(SignalHandler&& handler)
> {
>
>
> typedef typename handler_type<SignalHandler, void(boost::system::error_code, int)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const int*>(0))) == 1, "SignalHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const int>()), char(0))> type_check;
>
> return this->service.async_wait(this->implementation,
> static_cast<SignalHandler&&>(handler));
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 385 "/usr/include/boost/asio/basic_signal_set.hpp" 2 3 4
># 28 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 1 3 4
># 25 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
># 1 "/usr/include/boost/asio/socket_acceptor_service.hpp" 1 3 4
># 30 "/usr/include/boost/asio/socket_acceptor_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 31 "/usr/include/boost/asio/socket_acceptor_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>template <typename Protocol>
>class socket_acceptor_service
>
>
>
> : public boost::asio::detail::service_base<socket_acceptor_service<Protocol> >
>
>{
>public:
>
>
>
>
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename protocol_type::endpoint endpoint_type;
>
>private:
>
>
>
>
> typedef detail::reactive_socket_service<Protocol> service_impl_type;
>
>
>public:
>
>
>
>
> typedef typename service_impl_type::implementation_type implementation_type;
>
>
>
>
>
>
> typedef typename service_impl_type::native_handle_type native_type;
>
>
>
>
>
>
> typedef typename service_impl_type::native_handle_type native_handle_type;
>
>
>
> explicit socket_acceptor_service(boost::asio::io_service& io_service)
> : boost::asio::detail::service_base<
> socket_acceptor_service<Protocol> >(io_service),
> service_impl_(io_service)
> {
> }
>
>
> void construct(implementation_type& impl)
> {
> service_impl_.construct(impl);
> }
>
>
>
> void move_construct(implementation_type& impl,
> implementation_type& other_impl)
> {
> service_impl_.move_construct(impl, other_impl);
> }
>
>
> void move_assign(implementation_type& impl,
> socket_acceptor_service& other_service,
> implementation_type& other_impl)
> {
> service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
> }
>
>
>
> template <typename Protocol1>
> void converting_move_construct(implementation_type& impl,
> typename socket_acceptor_service<
> Protocol1>::implementation_type& other_impl,
> typename enable_if<is_convertible<
> Protocol1, Protocol>::value>::type* = 0)
> {
> service_impl_.template converting_move_construct<Protocol1>(
> impl, other_impl);
> }
>
>
>
> void destroy(implementation_type& impl)
> {
> service_impl_.destroy(impl);
> }
>
>
> boost::system::error_code open(implementation_type& impl,
> const protocol_type& protocol, boost::system::error_code& ec)
> {
> return service_impl_.open(impl, protocol, ec);
> }
>
>
> boost::system::error_code assign(implementation_type& impl,
> const protocol_type& protocol, const native_handle_type& native_acceptor,
> boost::system::error_code& ec)
> {
> return service_impl_.assign(impl, protocol, native_acceptor, ec);
> }
>
>
> bool is_open(const implementation_type& impl) const
> {
> return service_impl_.is_open(impl);
> }
>
>
> boost::system::error_code cancel(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.cancel(impl, ec);
> }
>
>
> boost::system::error_code bind(implementation_type& impl,
> const endpoint_type& endpoint, boost::system::error_code& ec)
> {
> return service_impl_.bind(impl, endpoint, ec);
> }
>
>
>
> boost::system::error_code listen(implementation_type& impl, int backlog,
> boost::system::error_code& ec)
> {
> return service_impl_.listen(impl, backlog, ec);
> }
>
>
> boost::system::error_code close(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.close(impl, ec);
> }
>
>
> native_type native(implementation_type& impl)
> {
> return service_impl_.native_handle(impl);
> }
>
>
> native_handle_type native_handle(implementation_type& impl)
> {
> return service_impl_.native_handle(impl);
> }
>
>
> template <typename SettableSocketOption>
> boost::system::error_code set_option(implementation_type& impl,
> const SettableSocketOption& option, boost::system::error_code& ec)
> {
> return service_impl_.set_option(impl, option, ec);
> }
>
>
> template <typename GettableSocketOption>
> boost::system::error_code get_option(const implementation_type& impl,
> GettableSocketOption& option, boost::system::error_code& ec) const
> {
> return service_impl_.get_option(impl, option, ec);
> }
>
>
> template <typename IoControlCommand>
> boost::system::error_code io_control(implementation_type& impl,
> IoControlCommand& command, boost::system::error_code& ec)
> {
> return service_impl_.io_control(impl, command, ec);
> }
>
>
> bool non_blocking(const implementation_type& impl) const
> {
> return service_impl_.non_blocking(impl);
> }
>
>
> boost::system::error_code non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> return service_impl_.non_blocking(impl, mode, ec);
> }
>
>
> bool native_non_blocking(const implementation_type& impl) const
> {
> return service_impl_.native_non_blocking(impl);
> }
>
>
> boost::system::error_code native_non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> return service_impl_.native_non_blocking(impl, mode, ec);
> }
>
>
> endpoint_type local_endpoint(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.local_endpoint(impl, ec);
> }
>
>
> template <typename Protocol1, typename SocketService>
> boost::system::error_code accept(implementation_type& impl,
> basic_socket<Protocol1, SocketService>& peer,
> endpoint_type* peer_endpoint, boost::system::error_code& ec,
> typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
> {
> return service_impl_.accept(impl, peer, peer_endpoint, ec);
> }
>
>
> template <typename Protocol1, typename SocketService, typename AcceptHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<AcceptHandler, void (boost::system::error_code)>::type>::type
>
> async_accept(implementation_type& impl,
> basic_socket<Protocol1, SocketService>& peer,
> endpoint_type* peer_endpoint,
> AcceptHandler&& handler,
> typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
> {
> detail::async_result_init<
> AcceptHandler, void (boost::system::error_code)> init(
> static_cast<AcceptHandler&&>(handler));
>
> service_impl_.async_accept(impl, peer, peer_endpoint, init.handler);
>
> return init.result.get();
> }
>
>private:
>
> void shutdown_service()
> {
> service_impl_.shutdown_service();
> }
>
>
> service_impl_type service_impl_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 299 "/usr/include/boost/asio/socket_acceptor_service.hpp" 2 3 4
># 26 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 29 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 53 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
>template <typename Protocol,
> typename SocketAcceptorService = socket_acceptor_service<Protocol> >
>class basic_socket_acceptor
> : public basic_io_object<SocketAcceptorService>,
> public socket_base
>{
>public:
>
>
> typedef typename SocketAcceptorService::native_handle_type native_type;
>
>
> typedef typename SocketAcceptorService::native_handle_type native_handle_type;
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
># 83 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> explicit basic_socket_acceptor(boost::asio::io_service& io_service)
> : basic_io_object<SocketAcceptorService>(io_service)
> {
> }
># 100 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> basic_socket_acceptor(boost::asio::io_service& io_service,
> const protocol_type& protocol)
> : basic_io_object<SocketAcceptorService>(io_service)
> {
> boost::system::error_code ec;
> this->get_service().open(this->get_implementation(), protocol, ec);
> boost::asio::detail::throw_error(ec, "open");
> }
># 136 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> basic_socket_acceptor(boost::asio::io_service& io_service,
> const endpoint_type& endpoint, bool reuse_addr = true)
> : basic_io_object<SocketAcceptorService>(io_service)
> {
> boost::system::error_code ec;
> const protocol_type protocol = endpoint.protocol();
> this->get_service().open(this->get_implementation(), protocol, ec);
> boost::asio::detail::throw_error(ec, "open");
> if (reuse_addr)
> {
> this->get_service().set_option(this->get_implementation(),
> socket_base::reuse_address(true), ec);
> boost::asio::detail::throw_error(ec, "set_option");
> }
> this->get_service().bind(this->get_implementation(), endpoint, ec);
> boost::asio::detail::throw_error(ec, "bind");
> this->get_service().listen(this->get_implementation(),
> socket_base::max_connections, ec);
> boost::asio::detail::throw_error(ec, "listen");
> }
># 172 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> basic_socket_acceptor(boost::asio::io_service& io_service,
> const protocol_type& protocol, const native_handle_type& native_acceptor)
> : basic_io_object<SocketAcceptorService>(io_service)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> protocol, native_acceptor, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 193 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> basic_socket_acceptor(basic_socket_acceptor&& other)
> : basic_io_object<SocketAcceptorService>(
> static_cast<basic_socket_acceptor&&>(other))
> {
> }
># 209 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> basic_socket_acceptor& operator=(basic_socket_acceptor&& other)
> {
> basic_io_object<SocketAcceptorService>::operator=(
> static_cast<basic_socket_acceptor&&>(other));
> return *this;
> }
>
>
> template <typename Protocol1, typename SocketAcceptorService1>
> friend class basic_socket_acceptor;
># 231 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename Protocol1, typename SocketAcceptorService1>
> basic_socket_acceptor(
> basic_socket_acceptor<Protocol1, SocketAcceptorService1>&& other,
> typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
> : basic_io_object<SocketAcceptorService>(other.get_io_service())
> {
> this->get_service().template converting_move_construct<Protocol1>(
> this->get_implementation(), other.get_implementation());
> }
># 252 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename Protocol1, typename SocketAcceptorService1>
> typename enable_if<is_convertible<Protocol1, Protocol>::value,
> basic_socket_acceptor>::type& operator=(
> basic_socket_acceptor<Protocol1, SocketAcceptorService1>&& other)
> {
> basic_socket_acceptor tmp(static_cast<basic_socket_acceptor< Protocol1, SocketAcceptorService1>&&>
> (other));
> basic_io_object<SocketAcceptorService>::operator=(
> static_cast<basic_socket_acceptor&&>(tmp));
> return *this;
> }
># 280 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void open(const protocol_type& protocol = protocol_type())
> {
> boost::system::error_code ec;
> this->get_service().open(this->get_implementation(), protocol, ec);
> boost::asio::detail::throw_error(ec, "open");
> }
># 307 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code open(const protocol_type& protocol,
> boost::system::error_code& ec)
> {
> return this->get_service().open(this->get_implementation(), protocol, ec);
> }
># 323 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void assign(const protocol_type& protocol,
> const native_handle_type& native_acceptor)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> protocol, native_acceptor, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 342 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code assign(const protocol_type& protocol,
> const native_handle_type& native_acceptor, boost::system::error_code& ec)
> {
> return this->get_service().assign(this->get_implementation(),
> protocol, native_acceptor, ec);
> }
>
>
> bool is_open() const
> {
> return this->get_service().is_open(this->get_implementation());
> }
># 373 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void bind(const endpoint_type& endpoint)
> {
> boost::system::error_code ec;
> this->get_service().bind(this->get_implementation(), endpoint, ec);
> boost::asio::detail::throw_error(ec, "bind");
> }
># 403 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code bind(const endpoint_type& endpoint,
> boost::system::error_code& ec)
> {
> return this->get_service().bind(this->get_implementation(), endpoint, ec);
> }
># 419 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void listen(int backlog = socket_base::max_connections)
> {
> boost::system::error_code ec;
> this->get_service().listen(this->get_implementation(), backlog, ec);
> boost::asio::detail::throw_error(ec, "listen");
> }
># 448 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code listen(int backlog, boost::system::error_code& ec)
> {
> return this->get_service().listen(this->get_implementation(), backlog, ec);
> }
># 463 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void close()
> {
> boost::system::error_code ec;
> this->get_service().close(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "close");
> }
># 492 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code close(boost::system::error_code& ec)
> {
> return this->get_service().close(this->get_implementation(), ec);
> }
>
>
>
>
>
>
>
> native_type native()
> {
> return this->get_service().native_handle(this->get_implementation());
> }
>
>
>
>
>
>
>
> native_handle_type native_handle()
> {
> return this->get_service().native_handle(this->get_implementation());
> }
># 527 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void cancel()
> {
> boost::system::error_code ec;
> this->get_service().cancel(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "cancel");
> }
># 542 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code cancel(boost::system::error_code& ec)
> {
> return this->get_service().cancel(this->get_implementation(), ec);
> }
># 568 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename SettableSocketOption>
> void set_option(const SettableSocketOption& option)
> {
> boost::system::error_code ec;
> this->get_service().set_option(this->get_implementation(), option, ec);
> boost::asio::detail::throw_error(ec, "set_option");
> }
># 602 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename SettableSocketOption>
> boost::system::error_code set_option(const SettableSocketOption& option,
> boost::system::error_code& ec)
> {
> return this->get_service().set_option(
> this->get_implementation(), option, ec);
> }
># 632 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename GettableSocketOption>
> void get_option(GettableSocketOption& option)
> {
> boost::system::error_code ec;
> this->get_service().get_option(this->get_implementation(), option, ec);
> boost::asio::detail::throw_error(ec, "get_option");
> }
># 667 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename GettableSocketOption>
> boost::system::error_code get_option(GettableSocketOption& option,
> boost::system::error_code& ec)
> {
> return this->get_service().get_option(
> this->get_implementation(), option, ec);
> }
># 695 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename IoControlCommand>
> void io_control(IoControlCommand& command)
> {
> boost::system::error_code ec;
> this->get_service().io_control(this->get_implementation(), command, ec);
> boost::asio::detail::throw_error(ec, "io_control");
> }
># 728 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename IoControlCommand>
> boost::system::error_code io_control(IoControlCommand& command,
> boost::system::error_code& ec)
> {
> return this->get_service().io_control(
> this->get_implementation(), command, ec);
> }
># 747 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> bool non_blocking() const
> {
> return this->get_service().non_blocking(this->get_implementation());
> }
># 765 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void non_blocking(bool mode)
> {
> boost::system::error_code ec;
> this->get_service().non_blocking(this->get_implementation(), mode, ec);
> boost::asio::detail::throw_error(ec, "non_blocking");
> }
># 785 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code non_blocking(
> bool mode, boost::system::error_code& ec)
> {
> return this->get_service().non_blocking(
> this->get_implementation(), mode, ec);
> }
># 806 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> bool native_non_blocking() const
> {
> return this->get_service().native_non_blocking(this->get_implementation());
> }
># 826 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void native_non_blocking(bool mode)
> {
> boost::system::error_code ec;
> this->get_service().native_non_blocking(
> this->get_implementation(), mode, ec);
> boost::asio::detail::throw_error(ec, "native_non_blocking");
> }
># 849 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code native_non_blocking(
> bool mode, boost::system::error_code& ec)
> {
> return this->get_service().native_non_blocking(
> this->get_implementation(), mode, ec);
> }
># 871 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> endpoint_type local_endpoint() const
> {
> boost::system::error_code ec;
> endpoint_type ep = this->get_service().local_endpoint(
> this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "local_endpoint");
> return ep;
> }
># 902 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> endpoint_type local_endpoint(boost::system::error_code& ec) const
> {
> return this->get_service().local_endpoint(this->get_implementation(), ec);
> }
># 925 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename Protocol1, typename SocketService>
> void accept(basic_socket<Protocol1, SocketService>& peer,
> typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
> {
> boost::system::error_code ec;
> this->get_service().accept(this->get_implementation(),
> peer, static_cast<endpoint_type*>(0), ec);
> boost::asio::detail::throw_error(ec, "accept");
> }
># 958 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename Protocol1, typename SocketService>
> boost::system::error_code accept(
> basic_socket<Protocol1, SocketService>& peer,
> boost::system::error_code& ec,
> typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
> {
> return this->get_service().accept(this->get_implementation(),
> peer, static_cast<endpoint_type*>(0), ec);
> }
># 1006 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename Protocol1, typename SocketService, typename AcceptHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<AcceptHandler, void (boost::system::error_code)>::type>::type
>
> async_accept(basic_socket<Protocol1, SocketService>& peer,
> AcceptHandler&& handler,
> typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
> {
>
>
> typedef typename handler_type<AcceptHandler, void(boost::system::error_code)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "AcceptHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> type_check;
>
> return this->get_service().async_accept(this->get_implementation(),
> peer, static_cast<endpoint_type*>(0),
> static_cast<AcceptHandler&&>(handler));
> }
># 1045 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename SocketService>
> void accept(basic_socket<protocol_type, SocketService>& peer,
> endpoint_type& peer_endpoint)
> {
> boost::system::error_code ec;
> this->get_service().accept(this->get_implementation(),
> peer, &peer_endpoint, ec);
> boost::asio::detail::throw_error(ec, "accept");
> }
># 1083 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename SocketService>
> boost::system::error_code accept(
> basic_socket<protocol_type, SocketService>& peer,
> endpoint_type& peer_endpoint, boost::system::error_code& ec)
> {
> return this->get_service().accept(
> this->get_implementation(), peer, &peer_endpoint, ec);
> }
># 1118 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename SocketService, typename AcceptHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<AcceptHandler, void (boost::system::error_code)>::type>::type
>
> async_accept(basic_socket<protocol_type, SocketService>& peer,
> endpoint_type& peer_endpoint, AcceptHandler&& handler)
> {
>
>
> typedef typename handler_type<AcceptHandler, void(boost::system::error_code)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "AcceptHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> type_check;
>
> return this->get_service().async_accept(this->get_implementation(), peer,
> &peer_endpoint, static_cast<AcceptHandler&&>(handler));
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 1137 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 2 3 4
># 29 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_socket_iostream.hpp" 1 3 4
># 24 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
># 1 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 1 3 4
># 25 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/array.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/array.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>using std::array;
>
>
>
>
>}
>}
>}
># 26 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/stream_socket_service.hpp" 1 3 4
># 19 "/usr/include/boost/asio/stream_socket_service.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/stream_socket_service.hpp" 2 3 4
># 31 "/usr/include/boost/asio/stream_socket_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 32 "/usr/include/boost/asio/stream_socket_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>template <typename Protocol>
>class stream_socket_service
>
>
>
> : public boost::asio::detail::service_base<stream_socket_service<Protocol> >
>
>{
>public:
>
>
>
>
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
>
>private:
>
>
>
>
> typedef detail::reactive_socket_service<Protocol> service_impl_type;
>
>
>public:
>
>
>
>
> typedef typename service_impl_type::implementation_type implementation_type;
>
>
>
>
>
>
> typedef typename service_impl_type::native_handle_type native_type;
>
>
>
>
>
>
> typedef typename service_impl_type::native_handle_type native_handle_type;
>
>
>
> explicit stream_socket_service(boost::asio::io_service& io_service)
> : boost::asio::detail::service_base<
> stream_socket_service<Protocol> >(io_service),
> service_impl_(io_service)
> {
> }
>
>
> void construct(implementation_type& impl)
> {
> service_impl_.construct(impl);
> }
>
>
>
> void move_construct(implementation_type& impl,
> implementation_type& other_impl)
> {
> service_impl_.move_construct(impl, other_impl);
> }
>
>
> void move_assign(implementation_type& impl,
> stream_socket_service& other_service,
> implementation_type& other_impl)
> {
> service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
> }
>
>
>
> template <typename Protocol1>
> void converting_move_construct(implementation_type& impl,
> typename stream_socket_service<
> Protocol1>::implementation_type& other_impl,
> typename enable_if<is_convertible<
> Protocol1, Protocol>::value>::type* = 0)
> {
> service_impl_.template converting_move_construct<Protocol1>(
> impl, other_impl);
> }
>
>
>
> void destroy(implementation_type& impl)
> {
> service_impl_.destroy(impl);
> }
>
>
> boost::system::error_code open(implementation_type& impl,
> const protocol_type& protocol, boost::system::error_code& ec)
> {
> if (protocol.type() == SOCK_STREAM)
> service_impl_.open(impl, protocol, ec);
> else
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
>
>
> boost::system::error_code assign(implementation_type& impl,
> const protocol_type& protocol, const native_handle_type& native_socket,
> boost::system::error_code& ec)
> {
> return service_impl_.assign(impl, protocol, native_socket, ec);
> }
>
>
> bool is_open(const implementation_type& impl) const
> {
> return service_impl_.is_open(impl);
> }
>
>
> boost::system::error_code close(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.close(impl, ec);
> }
>
>
> native_type native(implementation_type& impl)
> {
> return service_impl_.native_handle(impl);
> }
>
>
> native_handle_type native_handle(implementation_type& impl)
> {
> return service_impl_.native_handle(impl);
> }
>
>
> boost::system::error_code cancel(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.cancel(impl, ec);
> }
>
>
> bool at_mark(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.at_mark(impl, ec);
> }
>
>
> std::size_t available(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.available(impl, ec);
> }
>
>
> boost::system::error_code bind(implementation_type& impl,
> const endpoint_type& endpoint, boost::system::error_code& ec)
> {
> return service_impl_.bind(impl, endpoint, ec);
> }
>
>
> boost::system::error_code connect(implementation_type& impl,
> const endpoint_type& peer_endpoint, boost::system::error_code& ec)
> {
> return service_impl_.connect(impl, peer_endpoint, ec);
> }
>
>
> template <typename ConnectHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
>
> async_connect(implementation_type& impl,
> const endpoint_type& peer_endpoint,
> ConnectHandler&& handler)
> {
> detail::async_result_init<
> ConnectHandler, void (boost::system::error_code)> init(
> static_cast<ConnectHandler&&>(handler));
>
> service_impl_.async_connect(impl, peer_endpoint, init.handler);
>
> return init.result.get();
> }
>
>
> template <typename SettableSocketOption>
> boost::system::error_code set_option(implementation_type& impl,
> const SettableSocketOption& option, boost::system::error_code& ec)
> {
> return service_impl_.set_option(impl, option, ec);
> }
>
>
> template <typename GettableSocketOption>
> boost::system::error_code get_option(const implementation_type& impl,
> GettableSocketOption& option, boost::system::error_code& ec) const
> {
> return service_impl_.get_option(impl, option, ec);
> }
>
>
> template <typename IoControlCommand>
> boost::system::error_code io_control(implementation_type& impl,
> IoControlCommand& command, boost::system::error_code& ec)
> {
> return service_impl_.io_control(impl, command, ec);
> }
>
>
> bool non_blocking(const implementation_type& impl) const
> {
> return service_impl_.non_blocking(impl);
> }
>
>
> boost::system::error_code non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> return service_impl_.non_blocking(impl, mode, ec);
> }
>
>
> bool native_non_blocking(const implementation_type& impl) const
> {
> return service_impl_.native_non_blocking(impl);
> }
>
>
> boost::system::error_code native_non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> return service_impl_.native_non_blocking(impl, mode, ec);
> }
>
>
> endpoint_type local_endpoint(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.local_endpoint(impl, ec);
> }
>
>
> endpoint_type remote_endpoint(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return service_impl_.remote_endpoint(impl, ec);
> }
>
>
> boost::system::error_code shutdown(implementation_type& impl,
> socket_base::shutdown_type what, boost::system::error_code& ec)
> {
> return service_impl_.shutdown(impl, what, ec);
> }
>
>
> template <typename ConstBufferSequence>
> std::size_t send(implementation_type& impl,
> const ConstBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return service_impl_.send(impl, buffers, flags, ec);
> }
>
>
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send(implementation_type& impl,
> const ConstBufferSequence& buffers,
> socket_base::message_flags flags,
> WriteHandler&& handler)
> {
> detail::async_result_init<
> WriteHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<WriteHandler&&>(handler));
>
> service_impl_.async_send(impl, buffers, flags, init.handler);
>
> return init.result.get();
> }
>
>
> template <typename MutableBufferSequence>
> std::size_t receive(implementation_type& impl,
> const MutableBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return service_impl_.receive(impl, buffers, flags, ec);
> }
>
>
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive(implementation_type& impl,
> const MutableBufferSequence& buffers,
> socket_base::message_flags flags,
> ReadHandler&& handler)
> {
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> service_impl_.async_receive(impl, buffers, flags, init.handler);
>
> return init.result.get();
> }
>
>private:
>
> void shutdown_service()
> {
> service_impl_.shutdown_service();
> }
>
>
> service_impl_type service_impl_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 373 "/usr/include/boost/asio/stream_socket_service.hpp" 2 3 4
># 29 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/deadline_timer.hpp" 1 3 4
># 26 "/usr/include/boost/asio/deadline_timer.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/deadline_timer.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 29 "/usr/include/boost/asio/deadline_timer.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>typedef basic_deadline_timer<boost::posix_time::ptime> deadline_timer;
>
>}
>}
># 32 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 2 3 4
># 81 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 82 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>class socket_streambuf_base
>{
>protected:
> io_service io_service_;
>};
>
>}
>
>
>template <typename Protocol,
> typename StreamSocketService = stream_socket_service<Protocol>,
>
>
> typename Time = boost::posix_time::ptime,
> typename TimeTraits = boost::asio::time_traits<Time>,
> typename TimerService = deadline_timer_service<Time, TimeTraits> >
>
>
>
>
>
>class basic_socket_streambuf
> : public std::streambuf,
> private detail::socket_streambuf_base,
> public basic_socket<Protocol, StreamSocketService>
>{
>private:
>
>
>
> typedef TimeTraits traits_helper;
>
>
>
>
>public:
>
> typedef typename Protocol::endpoint endpoint_type;
># 135 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
> typedef typename traits_helper::time_type time_type;
> typedef typename traits_helper::duration_type duration_type;
>
>
>
> basic_socket_streambuf()
> : basic_socket<Protocol, StreamSocketService>(
> this->detail::socket_streambuf_base::io_service_),
> unbuffered_(false),
> timer_service_(0),
> timer_state_(no_timer)
> {
> init_buffers();
> }
>
>
> virtual ~basic_socket_streambuf()
> {
> if (pptr() != pbase())
> overflow(traits_type::eof());
>
> destroy_timer();
> }
># 166 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
> basic_socket_streambuf<Protocol, StreamSocketService,
> Time, TimeTraits, TimerService>* connect(
> const endpoint_type& endpoint)
> {
> init_buffers();
>
> this->basic_socket<Protocol, StreamSocketService>::close(ec_);
>
> if (timer_state_ == timer_has_expired)
> {
> ec_ = boost::asio::error::operation_aborted;
> return 0;
> }
>
> io_handler handler = { this };
> this->basic_socket<Protocol, StreamSocketService>::async_connect(
> endpoint, handler);
>
> ec_ = boost::asio::error::would_block;
> this->get_service().get_io_service().reset();
> do this->get_service().get_io_service().run_one();
> while (ec_ == boost::asio::error::would_block);
>
> return !ec_ ? this : 0;
> }
># 206 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
> template <typename... T>
> basic_socket_streambuf<Protocol, StreamSocketService,
> Time, TimeTraits, TimerService>* connect(T... x)
> {
> init_buffers();
> this->basic_socket<Protocol, StreamSocketService>::close(ec_);
> typedef typename Protocol::resolver resolver_type;
> typedef typename resolver_type::query resolver_query;
> resolver_query query(x...);
> resolve_and_connect(query);
> return !ec_ ? this : 0;
> }
># 229 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
> basic_socket_streambuf<Protocol, StreamSocketService,
> Time, TimeTraits, TimerService>* close()
> {
> sync();
> this->basic_socket<Protocol, StreamSocketService>::close(ec_);
> if (!ec_)
> init_buffers();
> return !ec_ ? this : 0;
> }
>
>
>
>
>
>
> const boost::system::error_code& puberror() const
> {
> return error();
> }
>
>
>
>
>
>
> time_type expires_at() const
> {
> return timer_service_
> ? timer_service_->expires_at(timer_implementation_)
> : time_type();
> }
># 270 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
> void expires_at(const time_type& expiry_time)
> {
> construct_timer();
>
> boost::system::error_code ec;
> timer_service_->expires_at(timer_implementation_, expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_at");
>
> start_timer();
> }
>
>
>
>
>
> duration_type expires_from_now() const
> {
> return traits_helper::subtract(expires_at(), traits_helper::now());
> }
># 299 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
> void expires_from_now(const duration_type& expiry_time)
> {
> construct_timer();
>
> boost::system::error_code ec;
> timer_service_->expires_from_now(timer_implementation_, expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_from_now");
>
> start_timer();
> }
>
>protected:
> int_type underflow()
> {
> if (gptr() == egptr())
> {
> if (timer_state_ == timer_has_expired)
> {
> ec_ = boost::asio::error::operation_aborted;
> return traits_type::eof();
> }
>
> io_handler handler = { this };
> this->get_service().async_receive(this->get_implementation(),
> boost::asio::buffer(boost::asio::buffer(get_buffer_) + putback_max),
> 0, handler);
>
> ec_ = boost::asio::error::would_block;
> this->get_service().get_io_service().reset();
> do this->get_service().get_io_service().run_one();
> while (ec_ == boost::asio::error::would_block);
> if (ec_)
> return traits_type::eof();
>
> setg(&get_buffer_[0], &get_buffer_[0] + putback_max,
> &get_buffer_[0] + putback_max + bytes_transferred_);
> return traits_type::to_int_type(*gptr());
> }
> else
> {
> return traits_type::eof();
> }
> }
>
> int_type overflow(int_type c)
> {
> if (unbuffered_)
> {
> if (traits_type::eq_int_type(c, traits_type::eof()))
> {
>
> return traits_type::not_eof(c);
> }
> else
> {
> if (timer_state_ == timer_has_expired)
> {
> ec_ = boost::asio::error::operation_aborted;
> return traits_type::eof();
> }
>
>
> char_type ch = traits_type::to_char_type(c);
> io_handler handler = { this };
> this->get_service().async_send(this->get_implementation(),
> boost::asio::buffer(&ch, sizeof(char_type)), 0, handler);
>
> ec_ = boost::asio::error::would_block;
> this->get_service().get_io_service().reset();
> do this->get_service().get_io_service().run_one();
> while (ec_ == boost::asio::error::would_block);
> if (ec_)
> return traits_type::eof();
>
> return c;
> }
> }
> else
> {
>
> boost::asio::const_buffer buffer =
> boost::asio::buffer(pbase(), pptr() - pbase());
> while (boost::asio::buffer_size(buffer) > 0)
> {
> if (timer_state_ == timer_has_expired)
> {
> ec_ = boost::asio::error::operation_aborted;
> return traits_type::eof();
> }
>
> io_handler handler = { this };
> this->get_service().async_send(this->get_implementation(),
> boost::asio::buffer(buffer), 0, handler);
>
> ec_ = boost::asio::error::would_block;
> this->get_service().get_io_service().reset();
> do this->get_service().get_io_service().run_one();
> while (ec_ == boost::asio::error::would_block);
> if (ec_)
> return traits_type::eof();
>
> buffer = buffer + bytes_transferred_;
> }
> setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());
>
>
> if (traits_type::eq_int_type(c, traits_type::eof()))
> return traits_type::not_eof(c);
>
>
> *pptr() = traits_type::to_char_type(c);
> pbump(1);
> return c;
> }
> }
>
> int sync()
> {
> return overflow(traits_type::eof());
> }
>
> std::streambuf* setbuf(char_type* s, std::streamsize n)
> {
> if (pptr() == pbase() && s == 0 && n == 0)
> {
> unbuffered_ = true;
> setp(0, 0);
> return this;
> }
>
> return 0;
> }
>
>
>
>
>
>
> virtual const boost::system::error_code& error() const
> {
> return ec_;
> }
>
>private:
> void init_buffers()
> {
> setg(&get_buffer_[0],
> &get_buffer_[0] + putback_max,
> &get_buffer_[0] + putback_max);
> if (unbuffered_)
> setp(0, 0);
> else
> setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());
> }
>
> template <typename ResolverQuery>
> void resolve_and_connect(const ResolverQuery& query)
> {
> typedef typename Protocol::resolver resolver_type;
> typedef typename resolver_type::iterator iterator_type;
> resolver_type resolver(detail::socket_streambuf_base::io_service_);
> iterator_type i = resolver.resolve(query, ec_);
> if (!ec_)
> {
> iterator_type end;
> ec_ = boost::asio::error::host_not_found;
> while (ec_ && i != end)
> {
> this->basic_socket<Protocol, StreamSocketService>::close(ec_);
>
> if (timer_state_ == timer_has_expired)
> {
> ec_ = boost::asio::error::operation_aborted;
> return;
> }
>
> io_handler handler = { this };
> this->basic_socket<Protocol, StreamSocketService>::async_connect(
> *i, handler);
>
> ec_ = boost::asio::error::would_block;
> this->get_service().get_io_service().reset();
> do this->get_service().get_io_service().run_one();
> while (ec_ == boost::asio::error::would_block);
>
> ++i;
> }
> }
> }
>
> struct io_handler;
> friend struct io_handler;
> struct io_handler
> {
> basic_socket_streambuf* this_;
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred = 0)
> {
> this_->ec_ = ec;
> this_->bytes_transferred_ = bytes_transferred;
> }
> };
>
> struct timer_handler;
> friend struct timer_handler;
> struct timer_handler
> {
> basic_socket_streambuf* this_;
>
> void operator()(const boost::system::error_code&)
> {
> time_type now = traits_helper::now();
>
> time_type expiry_time = this_->timer_service_->expires_at(
> this_->timer_implementation_);
>
> if (traits_helper::less_than(now, expiry_time))
> {
> this_->timer_state_ = timer_is_pending;
> this_->timer_service_->async_wait(this_->timer_implementation_, *this);
> }
> else
> {
> this_->timer_state_ = timer_has_expired;
> boost::system::error_code ec;
> this_->basic_socket<Protocol, StreamSocketService>::close(ec);
> }
> }
> };
>
> void construct_timer()
> {
> if (timer_service_ == 0)
> {
> TimerService& timer_service = use_service<TimerService>(
> detail::socket_streambuf_base::io_service_);
> timer_service.construct(timer_implementation_);
> timer_service_ = &timer_service;
> }
> }
>
> void destroy_timer()
> {
> if (timer_service_)
> timer_service_->destroy(timer_implementation_);
> }
>
> void start_timer()
> {
> if (timer_state_ != timer_is_pending)
> {
> timer_handler handler = { this };
> handler(boost::system::error_code());
> }
> }
>
> enum { putback_max = 8 };
> enum { buffer_size = 512 };
> boost::asio::detail::array<char, buffer_size> get_buffer_;
> boost::asio::detail::array<char, buffer_size> put_buffer_;
> bool unbuffered_;
> boost::system::error_code ec_;
> std::size_t bytes_transferred_;
> TimerService* timer_service_;
> typename TimerService::implementation_type timer_implementation_;
> enum state { no_timer, timer_is_pending, timer_has_expired } timer_state_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 572 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 2 3 4
># 25 "/usr/include/boost/asio/basic_socket_iostream.hpp" 2 3 4
># 85 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 86 "/usr/include/boost/asio/basic_socket_iostream.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>template <typename Protocol, typename StreamSocketService,
> typename Time, typename TimeTraits, typename TimerService>
>class socket_iostream_base
>{
>protected:
> basic_socket_streambuf<Protocol, StreamSocketService,
> Time, TimeTraits, TimerService> streambuf_;
>};
>
>}
>
>
>template <typename Protocol,
> typename StreamSocketService = stream_socket_service<Protocol>,
>
>
> typename Time = boost::posix_time::ptime,
> typename TimeTraits = boost::asio::time_traits<Time>,
> typename TimerService = deadline_timer_service<Time, TimeTraits> >
>
>
>
>
>
>class basic_socket_iostream
> : private detail::socket_iostream_base<Protocol,
> StreamSocketService, Time, TimeTraits, TimerService>,
> public std::basic_iostream<char>
>{
>private:
>
>
>
> typedef TimeTraits traits_helper;
>
>
>
>
>public:
>
> typedef typename Protocol::endpoint endpoint_type;
># 142 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
> typedef typename traits_helper::time_type time_type;
> typedef typename traits_helper::duration_type duration_type;
>
>
>
> basic_socket_iostream()
> : std::basic_iostream<char>(
> &this->detail::socket_iostream_base<
> Protocol, StreamSocketService, Time,
> TimeTraits, TimerService>::streambuf_)
> {
> this->setf(std::ios_base::unitbuf);
> }
># 166 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
> template <typename... T>
> explicit basic_socket_iostream(T... x)
> : std::basic_iostream<char>(
> &this->detail::socket_iostream_base<
> Protocol, StreamSocketService, Time,
> TimeTraits, TimerService>::streambuf_)
> {
> this->setf(std::ios_base::unitbuf);
> if (rdbuf()->connect(x...) == 0)
> this->setstate(std::ios_base::failbit);
> }
># 193 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
> template <typename... T>
> void connect(T... x)
> {
> if (rdbuf()->connect(x...) == 0)
> this->setstate(std::ios_base::failbit);
> }
>
>
>
>
>
>
>
> void close()
> {
> if (rdbuf()->close() == 0)
> this->setstate(std::ios_base::failbit);
> }
>
>
> basic_socket_streambuf<Protocol, StreamSocketService,
> Time, TimeTraits, TimerService>* rdbuf() const
> {
> return const_cast<basic_socket_streambuf<Protocol, StreamSocketService,
> Time, TimeTraits, TimerService>*>(
> &this->detail::socket_iostream_base<
> Protocol, StreamSocketService, Time,
> TimeTraits, TimerService>::streambuf_);
> }
># 235 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
> const boost::system::error_code& error() const
> {
> return rdbuf()->puberror();
> }
>
>
>
>
>
> time_type expires_at() const
> {
> return rdbuf()->expires_at();
> }
># 258 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
> void expires_at(const time_type& expiry_time)
> {
> rdbuf()->expires_at(expiry_time);
> }
>
>
>
>
>
> duration_type expires_from_now() const
> {
> return rdbuf()->expires_from_now();
> }
># 281 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
> void expires_from_now(const duration_type& expiry_time)
> {
> rdbuf()->expires_from_now(expiry_time);
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 291 "/usr/include/boost/asio/basic_socket_iostream.hpp" 2 3 4
># 30 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/basic_stream_socket.hpp" 1 3 4
># 19 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/basic_stream_socket.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/basic_stream_socket.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 44 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
>template <typename Protocol,
> typename StreamSocketService = stream_socket_service<Protocol> >
>class basic_stream_socket
> : public basic_socket<Protocol, StreamSocketService>
>{
>public:
>
>
> typedef typename StreamSocketService::native_handle_type native_type;
>
>
> typedef typename StreamSocketService::native_handle_type native_handle_type;
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
># 72 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> explicit basic_stream_socket(boost::asio::io_service& io_service)
> : basic_socket<Protocol, StreamSocketService>(io_service)
> {
> }
># 89 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> basic_stream_socket(boost::asio::io_service& io_service,
> const protocol_type& protocol)
> : basic_socket<Protocol, StreamSocketService>(io_service, protocol)
> {
> }
># 110 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> basic_stream_socket(boost::asio::io_service& io_service,
> const endpoint_type& endpoint)
> : basic_socket<Protocol, StreamSocketService>(io_service, endpoint)
> {
> }
># 130 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> basic_stream_socket(boost::asio::io_service& io_service,
> const protocol_type& protocol, const native_handle_type& native_socket)
> : basic_socket<Protocol, StreamSocketService>(
> io_service, protocol, native_socket)
> {
> }
># 148 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> basic_stream_socket(basic_stream_socket&& other)
> : basic_socket<Protocol, StreamSocketService>(
> static_cast<basic_stream_socket&&>(other))
> {
> }
># 164 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> basic_stream_socket& operator=(basic_stream_socket&& other)
> {
> basic_socket<Protocol, StreamSocketService>::operator=(
> static_cast<basic_stream_socket&&>(other));
> return *this;
> }
># 182 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename Protocol1, typename StreamSocketService1>
> basic_stream_socket(
> basic_stream_socket<Protocol1, StreamSocketService1>&& other,
> typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
> : basic_socket<Protocol, StreamSocketService>(
> static_cast<basic_stream_socket< Protocol1, StreamSocketService1>&&>
> (other))
> {
> }
># 202 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename Protocol1, typename StreamSocketService1>
> typename enable_if<is_convertible<Protocol1, Protocol>::value,
> basic_stream_socket>::type& operator=(
> basic_stream_socket<Protocol1, StreamSocketService1>&& other)
> {
> basic_socket<Protocol, StreamSocketService>::operator=(
> static_cast<basic_stream_socket< Protocol1, StreamSocketService1>&&>
> (other));
> return *this;
> }
># 239 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "send");
> return s;
> }
># 276 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> boost::asio::detail::throw_error(ec, "send");
> return s;
> }
># 305 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> }
># 348 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send(const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_send(
> this->get_implementation(), buffers, 0,
> static_cast<WriteHandler&&>(handler));
> }
># 400 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags,
> WriteHandler&& handler)
> {
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_send(
> this->get_implementation(), buffers, flags,
> static_cast<WriteHandler&&>(handler));
> }
># 444 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 484 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, flags, ec);
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 513 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return this->get_service().receive(
> this->get_implementation(), buffers, flags, ec);
> }
># 558 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive(const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_receive(this->get_implementation(),
> buffers, 0, static_cast<ReadHandler&&>(handler));
> }
># 611 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags,
> ReadHandler&& handler)
> {
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_receive(this->get_implementation(),
> buffers, flags, static_cast<ReadHandler&&>(handler));
> }
># 653 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "write_some");
> return s;
> }
># 679 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return this->get_service().send(this->get_implementation(), buffers, 0, ec);
> }
># 721 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_write_some(const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_send(this->get_implementation(),
> buffers, 0, static_cast<WriteHandler&&>(handler));
> }
># 763 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "read_some");
> return s;
> }
># 790 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return this->get_service().receive(
> this->get_implementation(), buffers, 0, ec);
> }
># 834 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_read_some(const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_receive(this->get_implementation(),
> buffers, 0, static_cast<ReadHandler&&>(handler));
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 853 "/usr/include/boost/asio/basic_stream_socket.hpp" 2 3 4
># 32 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_streambuf.hpp" 1 3 4
># 23 "/usr/include/boost/asio/basic_streambuf.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 24 "/usr/include/boost/asio/basic_streambuf.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/basic_streambuf_fwd.hpp" 1 3 4
># 24 "/usr/include/boost/asio/basic_streambuf_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>
>template <typename Allocator = std::allocator<char> >
>class basic_streambuf;
>
>}
>}
># 28 "/usr/include/boost/asio/basic_streambuf.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 34 "/usr/include/boost/asio/basic_streambuf.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 109 "/usr/include/boost/asio/basic_streambuf.hpp" 3 4
>template <typename Allocator>
>
>class basic_streambuf
> : public std::streambuf,
> private noncopyable
>{
>public:
>
>
>
>
>
>
>
> typedef boost::asio::const_buffers_1 const_buffers_type;
> typedef boost::asio::mutable_buffers_1 mutable_buffers_type;
>
>
>
>
>
>
>
> explicit basic_streambuf(
> std::size_t maximum_size = (std::numeric_limits<std::size_t>::max)(),
> const Allocator& allocator = Allocator())
> : max_size_(maximum_size),
> buffer_(allocator)
> {
> std::size_t pend = (std::min<std::size_t>)(max_size_, buffer_delta);
> buffer_.resize((std::max<std::size_t>)(pend, 1));
> setg(&buffer_[0], &buffer_[0], &buffer_[0]);
> setp(&buffer_[0], &buffer_[0] + pend);
> }
># 159 "/usr/include/boost/asio/basic_streambuf.hpp" 3 4
> std::size_t size() const
> {
> return pptr() - gptr();
> }
>
>
>
>
>
>
> std::size_t max_size() const
> {
> return max_size_;
> }
># 183 "/usr/include/boost/asio/basic_streambuf.hpp" 3 4
> const_buffers_type data() const
> {
> return boost::asio::buffer(boost::asio::const_buffer(gptr(),
> (pptr() - gptr()) * sizeof(char_type)));
> }
># 205 "/usr/include/boost/asio/basic_streambuf.hpp" 3 4
> mutable_buffers_type prepare(std::size_t n)
> {
> reserve(n);
> return boost::asio::buffer(boost::asio::mutable_buffer(
> pptr(), n * sizeof(char_type)));
> }
># 224 "/usr/include/boost/asio/basic_streambuf.hpp" 3 4
> void commit(std::size_t n)
> {
> if (pptr() + n > epptr())
> n = epptr() - pptr();
> pbump(static_cast<int>(n));
> setg(eback(), gptr(), pptr());
> }
>
>
>
>
>
>
>
> void consume(std::size_t n)
> {
> if (egptr() < pptr())
> setg(&buffer_[0], gptr(), pptr());
> if (gptr() + n > pptr())
> n = pptr() - gptr();
> gbump(static_cast<int>(n));
> }
>
>protected:
> enum { buffer_delta = 128 };
>
>
>
>
>
> int_type underflow()
> {
> if (gptr() < pptr())
> {
> setg(&buffer_[0], gptr(), pptr());
> return traits_type::to_int_type(*gptr());
> }
> else
> {
> return traits_type::eof();
> }
> }
># 274 "/usr/include/boost/asio/basic_streambuf.hpp" 3 4
> int_type overflow(int_type c)
> {
> if (!traits_type::eq_int_type(c, traits_type::eof()))
> {
> if (pptr() == epptr())
> {
> std::size_t buffer_size = pptr() - gptr();
> if (buffer_size < max_size_ && max_size_ - buffer_size < buffer_delta)
> {
> reserve(max_size_ - buffer_size);
> }
> else
> {
> reserve(buffer_delta);
> }
> }
>
> *pptr() = traits_type::to_char_type(c);
> pbump(1);
> return c;
> }
>
> return traits_type::not_eof(c);
> }
>
> void reserve(std::size_t n)
> {
>
> std::size_t gnext = gptr() - &buffer_[0];
> std::size_t pnext = pptr() - &buffer_[0];
> std::size_t pend = epptr() - &buffer_[0];
>
>
> if (n <= pend - pnext)
> {
> return;
> }
>
>
> if (gnext > 0)
> {
> pnext -= gnext;
> std::memmove(&buffer_[0], &buffer_[0] + gnext, pnext);
> }
>
>
> if (n > pend - pnext)
> {
> if (n <= max_size_ && pnext <= max_size_ - n)
> {
> pend = pnext + n;
> buffer_.resize((std::max<std::size_t>)(pend, 1));
> }
> else
> {
> std::length_error ex("boost::asio::streambuf too long");
> boost::asio::detail::throw_exception(ex);
> }
> }
>
>
> setg(&buffer_[0], &buffer_[0], &buffer_[0] + pnext);
> setp(&buffer_[0] + pnext, &buffer_[0] + pend);
> }
>
>private:
> std::size_t max_size_;
> std::vector<char_type, Allocator> buffer_;
>
>
> friend std::size_t read_size_helper(
> basic_streambuf& sb, std::size_t max_size)
> {
> return std::min<std::size_t>(
> std::max<std::size_t>(512, sb.buffer_.capacity() - sb.size()),
> std::min<std::size_t>(max_size, sb.max_size() - sb.size()));
> }
>};
>
>
>
>template <typename Allocator>
>inline std::size_t read_size_helper(
> basic_streambuf<Allocator>& sb, std::size_t max_size)
>{
> return std::min<std::size_t>(512,
> std::min<std::size_t>(max_size, sb.max_size() - sb.size()));
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 367 "/usr/include/boost/asio/basic_streambuf.hpp" 2 3 4
># 33 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_waitable_timer.hpp" 1 3 4
># 19 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/basic_waitable_timer.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/wait_traits.hpp" 1 3 4
># 18 "/usr/include/boost/asio/wait_traits.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 19 "/usr/include/boost/asio/wait_traits.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>template <typename Clock>
>struct wait_traits
>{
>
>
>
>
> static typename Clock::duration to_wait_duration(
> const typename Clock::duration& d)
> {
> return d;
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 42 "/usr/include/boost/asio/wait_traits.hpp" 2 3 4
># 25 "/usr/include/boost/asio/basic_waitable_timer.hpp" 2 3 4
># 1 "/usr/include/boost/asio/waitable_timer_service.hpp" 1 3 4
># 19 "/usr/include/boost/asio/waitable_timer_service.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/waitable_timer_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/chrono_time_traits.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/chrono_time_traits.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/chrono_time_traits.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>template <typename Clock, typename WaitTraits>
>struct chrono_time_traits
>{
>
> typedef Clock clock_type;
>
>
> typedef typename clock_type::duration duration_type;
>
>
> typedef typename clock_type::time_point time_type;
>
>
> typedef typename duration_type::period period_type;
>
>
> static time_type now()
> {
> return clock_type::now();
> }
>
>
> static time_type add(const time_type& t, const duration_type& d)
> {
> const time_type epoch;
> if (t >= epoch)
> {
> if ((time_type::max)() - t < d)
> return (time_type::max)();
> }
> else
> {
> if (-(t - (time_type::min)()) > d)
> return (time_type::min)();
> }
>
> return t + d;
> }
>
>
> static duration_type subtract(const time_type& t1, const time_type& t2)
> {
> const time_type epoch;
> if (t1 >= epoch)
> {
> if (t2 >= epoch)
> {
> return t1 - t2;
> }
> else if (t2 == (time_type::min)())
> {
> return (duration_type::max)();
> }
> else if ((time_type::max)() - t1 < epoch - t2)
> {
> return (duration_type::max)();
> }
> else
> {
> return t1 - t2;
> }
> }
> else
> {
> if (t2 < epoch)
> {
> return t1 - t2;
> }
> else if (t1 == (time_type::min)())
> {
> return (duration_type::min)();
> }
> else if ((time_type::max)() - t2 < epoch - t1)
> {
> return (duration_type::min)();
> }
> else
> {
> return -(t2 - t1);
> }
> }
> }
>
>
> static bool less_than(const time_type& t1, const time_type& t2)
> {
> return t1 < t2;
> }
>
>
>
> class posix_time_duration
> {
> public:
> explicit posix_time_duration(const duration_type& d)
> : d_(d)
> {
> }
>
> int64_t ticks() const
> {
> return d_.count();
> }
>
> int64_t total_seconds() const
> {
> return duration_cast<1, 1>();
> }
>
> int64_t total_milliseconds() const
> {
> return duration_cast<1, 1000>();
> }
>
> int64_t total_microseconds() const
> {
> return duration_cast<1, 1000000>();
> }
>
> private:
> template <int64_t Num, int64_t Den>
> int64_t duration_cast() const
> {
> const int64_t num = period_type::num * Den;
> const int64_t den = period_type::den * Num;
>
> if (num == 1 && den == 1)
> return ticks();
> else if (num != 1 && den == 1)
> return ticks() * num;
> else if (num == 1 && period_type::den != 1)
> return ticks() / den;
> else
> return ticks() * num / den;
> }
>
> duration_type d_;
> };
>
>
> static posix_time_duration to_posix_duration(const duration_type& d)
> {
> return posix_time_duration(WaitTraits::to_wait_duration(d));
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 178 "/usr/include/boost/asio/detail/chrono_time_traits.hpp" 2 3 4
># 22 "/usr/include/boost/asio/waitable_timer_service.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/waitable_timer_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>template <typename Clock,
> typename WaitTraits = boost::asio::wait_traits<Clock> >
>class waitable_timer_service
>
>
>
> : public boost::asio::detail::service_base<
> waitable_timer_service<Clock, WaitTraits> >
>
>{
>public:
>
>
>
>
>
>
> typedef Clock clock_type;
>
>
> typedef typename clock_type::duration duration;
>
>
> typedef typename clock_type::time_point time_point;
>
>
> typedef WaitTraits traits_type;
>
>private:
>
> typedef detail::deadline_timer_service<
> detail::chrono_time_traits<Clock, WaitTraits> > service_impl_type;
>
>public:
>
>
>
>
> typedef typename service_impl_type::implementation_type implementation_type;
>
>
>
> explicit waitable_timer_service(boost::asio::io_service& io_service)
> : boost::asio::detail::service_base<
> waitable_timer_service<Clock, WaitTraits> >(io_service),
> service_impl_(io_service)
> {
> }
>
>
> void construct(implementation_type& impl)
> {
> service_impl_.construct(impl);
> }
>
>
> void destroy(implementation_type& impl)
> {
> service_impl_.destroy(impl);
> }
>
>
> std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
> {
> return service_impl_.cancel(impl, ec);
> }
>
>
> std::size_t cancel_one(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.cancel_one(impl, ec);
> }
>
>
> time_point expires_at(const implementation_type& impl) const
> {
> return service_impl_.expires_at(impl);
> }
>
>
> std::size_t expires_at(implementation_type& impl,
> const time_point& expiry_time, boost::system::error_code& ec)
> {
> return service_impl_.expires_at(impl, expiry_time, ec);
> }
>
>
> duration expires_from_now(const implementation_type& impl) const
> {
> return service_impl_.expires_from_now(impl);
> }
>
>
> std::size_t expires_from_now(implementation_type& impl,
> const duration& expiry_time, boost::system::error_code& ec)
> {
> return service_impl_.expires_from_now(impl, expiry_time, ec);
> }
>
>
> void wait(implementation_type& impl, boost::system::error_code& ec)
> {
> service_impl_.wait(impl, ec);
> }
>
>
> template <typename WaitHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
>
> async_wait(implementation_type& impl,
> WaitHandler&& handler)
> {
> detail::async_result_init<
> WaitHandler, void (boost::system::error_code)> init(
> static_cast<WaitHandler&&>(handler));
>
> service_impl_.async_wait(impl, init.handler);
>
> return init.result.get();
> }
>
>private:
>
> void shutdown_service()
> {
> service_impl_.shutdown_service();
> }
>
>
> service_impl_type service_impl_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 169 "/usr/include/boost/asio/waitable_timer_service.hpp" 2 3 4
># 26 "/usr/include/boost/asio/basic_waitable_timer.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/basic_waitable_timer.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 124 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
>template <typename Clock,
> typename WaitTraits = boost::asio::wait_traits<Clock>,
> typename WaitableTimerService = waitable_timer_service<Clock, WaitTraits> >
>class basic_waitable_timer
> : public basic_io_object<WaitableTimerService>
>{
>public:
>
> typedef Clock clock_type;
>
>
> typedef typename clock_type::duration duration;
>
>
> typedef typename clock_type::time_point time_point;
>
>
> typedef WaitTraits traits_type;
># 152 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> explicit basic_waitable_timer(boost::asio::io_service& io_service)
> : basic_io_object<WaitableTimerService>(io_service)
> {
> }
># 167 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> basic_waitable_timer(boost::asio::io_service& io_service,
> const time_point& expiry_time)
> : basic_io_object<WaitableTimerService>(io_service)
> {
> boost::system::error_code ec;
> this->service.expires_at(this->implementation, expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_at");
> }
># 186 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> basic_waitable_timer(boost::asio::io_service& io_service,
> const duration& expiry_time)
> : basic_io_object<WaitableTimerService>(io_service)
> {
> boost::system::error_code ec;
> this->service.expires_from_now(this->implementation, expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_from_now");
> }
># 217 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t cancel()
> {
> boost::system::error_code ec;
> std::size_t s = this->service.cancel(this->implementation, ec);
> boost::asio::detail::throw_error(ec, "cancel");
> return s;
> }
># 247 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t cancel(boost::system::error_code& ec)
> {
> return this->service.cancel(this->implementation, ec);
> }
># 276 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t cancel_one()
> {
> boost::system::error_code ec;
> std::size_t s = this->service.cancel_one(this->implementation, ec);
> boost::asio::detail::throw_error(ec, "cancel_one");
> return s;
> }
># 308 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t cancel_one(boost::system::error_code& ec)
> {
> return this->service.cancel_one(this->implementation, ec);
> }
>
>
>
>
>
>
> time_point expires_at() const
> {
> return this->service.expires_at(this->implementation);
> }
># 345 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t expires_at(const time_point& expiry_time)
> {
> boost::system::error_code ec;
> std::size_t s = this->service.expires_at(
> this->implementation, expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_at");
> return s;
> }
># 376 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t expires_at(const time_point& expiry_time,
> boost::system::error_code& ec)
> {
> return this->service.expires_at(this->implementation, expiry_time, ec);
> }
>
>
>
>
>
>
> duration expires_from_now() const
> {
> return this->service.expires_from_now(this->implementation);
> }
># 414 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t expires_from_now(const duration& expiry_time)
> {
> boost::system::error_code ec;
> std::size_t s = this->service.expires_from_now(
> this->implementation, expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_from_now");
> return s;
> }
># 445 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t expires_from_now(const duration& expiry_time,
> boost::system::error_code& ec)
> {
> return this->service.expires_from_now(
> this->implementation, expiry_time, ec);
> }
># 459 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> void wait()
> {
> boost::system::error_code ec;
> this->service.wait(this->implementation, ec);
> boost::asio::detail::throw_error(ec, "wait");
> }
># 473 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> void wait(boost::system::error_code& ec)
> {
> this->service.wait(this->implementation, ec);
> }
># 502 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> template <typename WaitHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
>
> async_wait(WaitHandler&& handler)
> {
>
>
> typedef typename handler_type<WaitHandler, void(boost::system::error_code)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> type_check;
>
> return this->service.async_wait(this->implementation,
> static_cast<WaitHandler&&>(handler));
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 520 "/usr/include/boost/asio/basic_waitable_timer.hpp" 2 3 4
># 34 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/buffered_read_stream_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/asio/buffered_read_stream_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>
>template <typename Stream>
>class buffered_read_stream;
>
>}
>}
># 36 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/buffered_read_stream.hpp" 1 3 4
># 19 "/usr/include/boost/asio/buffered_read_stream.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/buffered_read_stream.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/buffer_resize_guard.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/buffer_resize_guard.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/buffer_resize_guard.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>template <typename Buffer>
>class buffer_resize_guard
>{
>public:
>
> buffer_resize_guard(Buffer& buffer)
> : buffer_(buffer),
> old_size_(buffer.size())
> {
> }
>
>
> ~buffer_resize_guard()
> {
> if (old_size_ != (std::numeric_limits<size_t>::max)())
> {
> buffer_.resize(old_size_);
> }
> }
>
>
> void commit()
> {
> old_size_ = (std::numeric_limits<size_t>::max)();
> }
>
>private:
>
> Buffer& buffer_;
>
>
> size_t old_size_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/buffer_resize_guard.hpp" 2 3 4
># 24 "/usr/include/boost/asio/buffered_read_stream.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/buffered_stream_storage.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/buffered_stream_storage.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 22 "/usr/include/boost/asio/detail/buffered_stream_storage.hpp" 2 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 23 "/usr/include/boost/asio/detail/buffered_stream_storage.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/buffered_stream_storage.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class buffered_stream_storage
>{
>public:
>
> typedef unsigned char byte_type;
>
>
> typedef std::size_t size_type;
>
>
> explicit buffered_stream_storage(std::size_t buffer_capacity)
> : begin_offset_(0),
> end_offset_(0),
> buffer_(buffer_capacity)
> {
> }
>
>
> void clear()
> {
> begin_offset_ = 0;
> end_offset_ = 0;
> }
>
>
> mutable_buffer data()
> {
> return boost::asio::buffer(buffer_) + begin_offset_;
> }
>
>
> const_buffer data() const
> {
> return boost::asio::buffer(buffer_) + begin_offset_;
> }
>
>
> bool empty() const
> {
> return begin_offset_ == end_offset_;
> }
>
>
> size_type size() const
> {
> return end_offset_ - begin_offset_;
> }
>
>
> void resize(size_type length)
> {
> ((void)0);
> if (begin_offset_ + length <= capacity())
> {
> end_offset_ = begin_offset_ + length;
> }
> else
> {
> using namespace std;
> memmove(&buffer_[0], &buffer_[0] + begin_offset_, size());
> end_offset_ = length;
> begin_offset_ = 0;
> }
> }
>
>
> size_type capacity() const
> {
> return buffer_.size();
> }
>
>
> void consume(size_type count)
> {
> ((void)0);
> begin_offset_ += count;
> if (empty())
> clear();
> }
>
>private:
>
> size_type begin_offset_;
>
>
> size_type end_offset_;
>
>
> std::vector<byte_type> buffer_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 127 "/usr/include/boost/asio/detail/buffered_stream_storage.hpp" 2 3 4
># 25 "/usr/include/boost/asio/buffered_read_stream.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 31 "/usr/include/boost/asio/buffered_read_stream.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 47 "/usr/include/boost/asio/buffered_read_stream.hpp" 3 4
>template <typename Stream>
>class buffered_read_stream
> : private noncopyable
>{
>public:
>
> typedef typename remove_reference<Stream>::type next_layer_type;
>
>
> typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
>
>
>
>
>
> static const std::size_t default_buffer_size = 1024;
>
>
>
> template <typename Arg>
> explicit buffered_read_stream(Arg& a)
> : next_layer_(a),
> storage_(default_buffer_size)
> {
> }
>
>
> template <typename Arg>
> buffered_read_stream(Arg& a, std::size_t buffer_size)
> : next_layer_(a),
> storage_(buffer_size)
> {
> }
>
>
> next_layer_type& next_layer()
> {
> return next_layer_;
> }
>
>
> lowest_layer_type& lowest_layer()
> {
> return next_layer_.lowest_layer();
> }
>
>
> const lowest_layer_type& lowest_layer() const
> {
> return next_layer_.lowest_layer();
> }
>
>
> boost::asio::io_service& get_io_service()
> {
> return next_layer_.get_io_service();
> }
>
>
> void close()
> {
> next_layer_.close();
> }
>
>
> boost::system::error_code close(boost::system::error_code& ec)
> {
> return next_layer_.close(ec);
> }
>
>
>
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers)
> {
> return next_layer_.write_some(buffers);
> }
>
>
>
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return next_layer_.write_some(buffers, ec);
> }
>
>
>
> template <typename ConstBufferSequence, typename WriteHandler>
> void async_write_some(const ConstBufferSequence& buffers,
> WriteHandler handler)
> {
> next_layer_.async_write_some(buffers, handler);
> }
>
>
>
> std::size_t fill()
> {
> detail::buffer_resize_guard<detail::buffered_stream_storage>
> resize_guard(storage_);
> std::size_t previous_size = storage_.size();
> storage_.resize(storage_.capacity());
> storage_.resize(previous_size + next_layer_.read_some(buffer(
> storage_.data() + previous_size,
> storage_.size() - previous_size)));
> resize_guard.commit();
> return storage_.size() - previous_size;
> }
>
>
>
> std::size_t fill(boost::system::error_code& ec)
> {
> detail::buffer_resize_guard<detail::buffered_stream_storage>
> resize_guard(storage_);
> std::size_t previous_size = storage_.size();
> storage_.resize(storage_.capacity());
> storage_.resize(previous_size + next_layer_.read_some(buffer(
> storage_.data() + previous_size,
> storage_.size() - previous_size),
> ec));
> resize_guard.commit();
> return storage_.size() - previous_size;
> }
>
> template <typename ReadHandler>
> class fill_handler
> {
> public:
> fill_handler(boost::asio::io_service& io_service,
> detail::buffered_stream_storage& storage,
> std::size_t previous_size, ReadHandler handler)
> : io_service_(io_service),
> storage_(storage),
> previous_size_(previous_size),
> handler_(handler)
> {
> }
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred)
> {
> storage_.resize(previous_size_ + bytes_transferred);
> io_service_.dispatch(detail::bind_handler(
> handler_, ec, bytes_transferred));
> }
>
> private:
> boost::asio::io_service& io_service_;
> detail::buffered_stream_storage& storage_;
> std::size_t previous_size_;
> ReadHandler handler_;
> };
>
>
> template <typename ReadHandler>
> void async_fill(ReadHandler handler)
> {
> std::size_t previous_size = storage_.size();
> storage_.resize(storage_.capacity());
> next_layer_.async_read_some(
> buffer(
> storage_.data() + previous_size,
> storage_.size() - previous_size),
> fill_handler<ReadHandler>(get_io_service(),
> storage_, previous_size, handler));
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers)
> {
> if (boost::asio::buffer_size(buffers) == 0)
> return 0;
>
> if (storage_.empty())
> fill();
>
> return copy(buffers);
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> ec = boost::system::error_code();
>
> if (boost::asio::buffer_size(buffers) == 0)
> return 0;
>
> if (storage_.empty() && !fill(ec))
> return 0;
>
> return copy(buffers);
> }
>
> template <typename MutableBufferSequence, typename ReadHandler>
> class read_some_handler
> {
> public:
> read_some_handler(boost::asio::io_service& io_service,
> detail::buffered_stream_storage& storage,
> const MutableBufferSequence& buffers, ReadHandler handler)
> : io_service_(io_service),
> storage_(storage),
> buffers_(buffers),
> handler_(handler)
> {
> }
>
> void operator()(const boost::system::error_code& ec, std::size_t)
> {
> if (ec || storage_.empty())
> {
> std::size_t length = 0;
> io_service_.dispatch(detail::bind_handler(handler_, ec, length));
> }
> else
> {
> std::size_t bytes_copied = boost::asio::buffer_copy(
> buffers_, storage_.data(), storage_.size());
> storage_.consume(bytes_copied);
> io_service_.dispatch(detail::bind_handler(handler_, ec, bytes_copied));
> }
> }
>
> private:
> boost::asio::io_service& io_service_;
> detail::buffered_stream_storage& storage_;
> MutableBufferSequence buffers_;
> ReadHandler handler_;
> };
>
>
>
> template <typename MutableBufferSequence, typename ReadHandler>
> void async_read_some(const MutableBufferSequence& buffers,
> ReadHandler handler)
> {
> if (boost::asio::buffer_size(buffers) == 0)
> {
> get_io_service().post(detail::bind_handler(
> handler, boost::system::error_code(), 0));
> }
> else if (storage_.empty())
> {
> async_fill(read_some_handler<MutableBufferSequence, ReadHandler>(
> get_io_service(), storage_, buffers, handler));
> }
> else
> {
> std::size_t length = copy(buffers);
> get_io_service().post(detail::bind_handler(
> handler, boost::system::error_code(), length));
> }
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t peek(const MutableBufferSequence& buffers)
> {
> if (storage_.empty())
> fill();
> return peek_copy(buffers);
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t peek(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> ec = boost::system::error_code();
> if (storage_.empty() && !fill(ec))
> return 0;
> return peek_copy(buffers);
> }
>
>
> std::size_t in_avail()
> {
> return storage_.size();
> }
>
>
> std::size_t in_avail(boost::system::error_code& ec)
> {
> ec = boost::system::error_code();
> return storage_.size();
> }
>
>private:
>
>
> template <typename MutableBufferSequence>
> std::size_t copy(const MutableBufferSequence& buffers)
> {
> std::size_t bytes_copied = boost::asio::buffer_copy(
> buffers, storage_.data(), storage_.size());
> storage_.consume(bytes_copied);
> return bytes_copied;
> }
>
>
>
>
> template <typename MutableBufferSequence>
> std::size_t peek_copy(const MutableBufferSequence& buffers)
> {
> return boost::asio::buffer_copy(buffers, storage_.data(), storage_.size());
> }
>
>
> Stream next_layer_;
>
>
> detail::buffered_stream_storage storage_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 376 "/usr/include/boost/asio/buffered_read_stream.hpp" 2 3 4
># 37 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/buffered_stream_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/asio/buffered_stream_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>
>template <typename Stream>
>class buffered_stream;
>
>}
>}
># 38 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/buffered_stream.hpp" 1 3 4
># 19 "/usr/include/boost/asio/buffered_stream.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/buffered_stream.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/buffered_write_stream.hpp" 1 3 4
># 19 "/usr/include/boost/asio/buffered_write_stream.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/buffered_write_stream.hpp" 2 3 4
># 1 "/usr/include/boost/asio/buffered_write_stream_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/asio/buffered_write_stream_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>
>template <typename Stream>
>class buffered_write_stream;
>
>}
>}
># 21 "/usr/include/boost/asio/buffered_write_stream.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/completion_condition.hpp" 1 3 4
># 19 "/usr/include/boost/asio/completion_condition.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/completion_condition.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/completion_condition.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail {
>
>
>enum { default_max_transfer_size = 65536 };
>
>
>
>inline std::size_t adapt_completion_condition_result(bool result)
>{
> return result ? 0 : default_max_transfer_size;
>}
>
>
>
>
>inline std::size_t adapt_completion_condition_result(std::size_t result)
>{
> return result;
>}
>
>class transfer_all_t
>{
>public:
> typedef std::size_t result_type;
>
> template <typename Error>
> std::size_t operator()(const Error& err, std::size_t)
> {
> return !!err ? 0 : default_max_transfer_size;
> }
>};
>
>class transfer_at_least_t
>{
>public:
> typedef std::size_t result_type;
>
> explicit transfer_at_least_t(std::size_t minimum)
> : minimum_(minimum)
> {
> }
>
> template <typename Error>
> std::size_t operator()(const Error& err, std::size_t bytes_transferred)
> {
> return (!!err || bytes_transferred >= minimum_)
> ? 0 : default_max_transfer_size;
> }
>
>private:
> std::size_t minimum_;
>};
>
>class transfer_exactly_t
>{
>public:
> typedef std::size_t result_type;
>
> explicit transfer_exactly_t(std::size_t size)
> : size_(size)
> {
> }
>
> template <typename Error>
> std::size_t operator()(const Error& err, std::size_t bytes_transferred)
> {
> return (!!err || bytes_transferred >= size_) ? 0 :
> (size_ - bytes_transferred < default_max_transfer_size
> ? size_ - bytes_transferred : std::size_t(default_max_transfer_size));
> }
>
>private:
> std::size_t size_;
>};
>
>}
># 139 "/usr/include/boost/asio/completion_condition.hpp" 3 4
>inline detail::transfer_all_t transfer_all()
>{
> return detail::transfer_all_t();
>}
># 173 "/usr/include/boost/asio/completion_condition.hpp" 3 4
>inline detail::transfer_at_least_t transfer_at_least(std::size_t minimum)
>{
> return detail::transfer_at_least_t(minimum);
>}
># 207 "/usr/include/boost/asio/completion_condition.hpp" 3 4
>inline detail::transfer_exactly_t transfer_exactly(std::size_t size)
>{
> return detail::transfer_exactly_t(size);
>}
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 219 "/usr/include/boost/asio/completion_condition.hpp" 2 3 4
># 23 "/usr/include/boost/asio/buffered_write_stream.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/write.hpp" 1 3 4
># 19 "/usr/include/boost/asio/write.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/write.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 25 "/usr/include/boost/asio/write.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 72 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename ConstBufferSequence>
>std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers);
># 111 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename ConstBufferSequence>
>std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
> boost::system::error_code& ec);
># 161 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition>
>std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition);
># 205 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition>
>std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec);
># 238 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename Allocator>
>std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b);
># 267 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename Allocator>
>std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
> boost::system::error_code& ec);
># 306 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename Allocator,
> typename CompletionCondition>
>std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition);
># 347 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename Allocator,
> typename CompletionCondition>
>std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition, boost::system::error_code& ec);
># 415 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
> WriteHandler&& handler);
># 489 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition,
> WriteHandler&& handler);
># 540 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
> WriteHandler&& handler);
># 601 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename AsyncWriteStream, typename Allocator,
> typename CompletionCondition, typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition,
> WriteHandler&& handler);
>
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 617 "/usr/include/boost/asio/write.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/write.hpp" 1 3 4
># 21 "/usr/include/boost/asio/impl/write.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/base_from_completion_cond.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/base_from_completion_cond.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/base_from_completion_cond.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename CompletionCondition>
>class base_from_completion_cond
>{
>protected:
> explicit base_from_completion_cond(CompletionCondition completion_condition)
> : completion_condition_(completion_condition)
> {
> }
>
> std::size_t check_for_completion(
> const boost::system::error_code& ec,
> std::size_t total_transferred)
> {
> return detail::adapt_completion_condition_result(
> completion_condition_(ec, total_transferred));
> }
>
>private:
> CompletionCondition completion_condition_;
>};
>
>template <>
>class base_from_completion_cond<transfer_all_t>
>{
>protected:
> explicit base_from_completion_cond(transfer_all_t)
> {
> }
>
> static std::size_t check_for_completion(
> const boost::system::error_code& ec,
> std::size_t total_transferred)
> {
> return transfer_all_t()(ec, total_transferred);
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 69 "/usr/include/boost/asio/detail/base_from_completion_cond.hpp" 2 3 4
># 22 "/usr/include/boost/asio/impl/write.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/consuming_buffers.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/consuming_buffers.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/detail/consuming_buffers.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/consuming_buffers.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>template <typename Buffer, typename Buffer_Iterator>
>class consuming_buffers_iterator
>{
>public:
>
> typedef std::ptrdiff_t difference_type;
>
>
> typedef Buffer value_type;
>
>
> typedef const Buffer* pointer;
>
>
> typedef const Buffer& reference;
>
>
> typedef std::forward_iterator_tag iterator_category;
>
>
> consuming_buffers_iterator()
> : at_end_(true)
> {
> }
>
>
>
> consuming_buffers_iterator(bool at_end, const Buffer& first,
> Buffer_Iterator begin_remainder, Buffer_Iterator end_remainder,
> std::size_t max_size)
> : at_end_(max_size > 0 ? at_end : true),
> first_(buffer(first, max_size)),
> begin_remainder_(begin_remainder),
> end_remainder_(end_remainder),
> offset_(0),
> max_size_(max_size)
> {
> }
>
>
> const Buffer& operator*() const
> {
> return dereference();
> }
>
>
> const Buffer* operator->() const
> {
> return &dereference();
> }
>
>
> consuming_buffers_iterator& operator++()
> {
> increment();
> return *this;
> }
>
>
> consuming_buffers_iterator operator++(int)
> {
> consuming_buffers_iterator tmp(*this);
> ++*this;
> return tmp;
> }
>
>
> friend bool operator==(const consuming_buffers_iterator& a,
> const consuming_buffers_iterator& b)
> {
> return a.equal(b);
> }
>
>
> friend bool operator!=(const consuming_buffers_iterator& a,
> const consuming_buffers_iterator& b)
> {
> return !a.equal(b);
> }
>
>private:
> void increment()
> {
> if (!at_end_)
> {
> if (begin_remainder_ == end_remainder_
> || offset_ + buffer_size(first_) >= max_size_)
> {
> at_end_ = true;
> }
> else
> {
> offset_ += buffer_size(first_);
> first_ = buffer(*begin_remainder_++, max_size_ - offset_);
> }
> }
> }
>
> bool equal(const consuming_buffers_iterator& other) const
> {
> if (at_end_ && other.at_end_)
> return true;
> return !at_end_ && !other.at_end_
> && buffer_cast<const void*>(first_)
> == buffer_cast<const void*>(other.first_)
> && buffer_size(first_) == buffer_size(other.first_)
> && begin_remainder_ == other.begin_remainder_
> && end_remainder_ == other.end_remainder_;
> }
>
> const Buffer& dereference() const
> {
> return first_;
> }
>
> bool at_end_;
> Buffer first_;
> Buffer_Iterator begin_remainder_;
> Buffer_Iterator end_remainder_;
> std::size_t offset_;
> std::size_t max_size_;
>};
>
>
>template <typename Buffer, typename Buffers>
>class consuming_buffers
>{
>public:
>
> typedef Buffer value_type;
>
>
> typedef consuming_buffers_iterator<Buffer, typename Buffers::const_iterator>
> const_iterator;
>
>
> consuming_buffers(const Buffers& buffers)
> : buffers_(buffers),
> at_end_(buffers_.begin() == buffers_.end()),
> begin_remainder_(buffers_.begin()),
> max_size_((std::numeric_limits<std::size_t>::max)())
> {
> if (!at_end_)
> {
> first_ = *buffers_.begin();
> ++begin_remainder_;
> }
> }
>
>
> consuming_buffers(const consuming_buffers& other)
> : buffers_(other.buffers_),
> at_end_(other.at_end_),
> first_(other.first_),
> begin_remainder_(buffers_.begin()),
> max_size_(other.max_size_)
> {
> typename Buffers::const_iterator first = other.buffers_.begin();
> typename Buffers::const_iterator second = other.begin_remainder_;
> std::advance(begin_remainder_, std::distance(first, second));
> }
>
>
> consuming_buffers& operator=(const consuming_buffers& other)
> {
> buffers_ = other.buffers_;
> at_end_ = other.at_end_;
> first_ = other.first_;
> begin_remainder_ = buffers_.begin();
> typename Buffers::const_iterator first = other.buffers_.begin();
> typename Buffers::const_iterator second = other.begin_remainder_;
> std::advance(begin_remainder_, std::distance(first, second));
> max_size_ = other.max_size_;
> return *this;
> }
>
>
> const_iterator begin() const
> {
> return const_iterator(at_end_, first_,
> begin_remainder_, buffers_.end(), max_size_);
> }
>
>
> const_iterator end() const
> {
> return const_iterator();
> }
>
>
> void prepare(std::size_t max_size)
> {
> max_size_ = max_size;
> }
>
>
> void consume(std::size_t size)
> {
>
> while (size > 0 && !at_end_)
> {
> if (buffer_size(first_) <= size)
> {
> size -= buffer_size(first_);
> if (begin_remainder_ == buffers_.end())
> at_end_ = true;
> else
> first_ = *begin_remainder_++;
> }
> else
> {
> first_ = first_ + size;
> size = 0;
> }
> }
>
>
> while (!at_end_ && buffer_size(first_) == 0)
> {
> if (begin_remainder_ == buffers_.end())
> at_end_ = true;
> else
> first_ = *begin_remainder_++;
> }
> }
>
>private:
> Buffers buffers_;
> bool at_end_;
> Buffer first_;
> typename Buffers::const_iterator begin_remainder_;
> std::size_t max_size_;
>};
>
>
>
>template <typename Buffer>
>class consuming_buffers<Buffer, boost::asio::null_buffers>
> : public boost::asio::null_buffers
>{
>public:
> consuming_buffers(const boost::asio::null_buffers&)
> {
>
> }
>
> void prepare(std::size_t)
> {
>
> }
>
> void consume(std::size_t)
> {
>
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 293 "/usr/include/boost/asio/detail/consuming_buffers.hpp" 2 3 4
># 24 "/usr/include/boost/asio/impl/write.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/dependent_type.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/dependent_type.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/dependent_type.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename DependsOn, typename T>
>struct dependent_type
>{
> typedef T type;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 37 "/usr/include/boost/asio/detail/dependent_type.hpp" 2 3 4
># 25 "/usr/include/boost/asio/impl/write.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 32 "/usr/include/boost/asio/impl/write.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>template <typename SyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition>
>std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> boost::asio::detail::consuming_buffers<
> const_buffer, ConstBufferSequence> tmp(buffers);
> std::size_t total_transferred = 0;
> tmp.prepare(detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred)));
> while (tmp.begin() != tmp.end())
> {
> std::size_t bytes_transferred = s.write_some(tmp, ec);
> tmp.consume(bytes_transferred);
> total_transferred += bytes_transferred;
> tmp.prepare(detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred)));
> }
> return total_transferred;
>}
>
>template <typename SyncWriteStream, typename ConstBufferSequence>
>inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write(s, buffers, transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "write");
> return bytes_transferred;
>}
>
>template <typename SyncWriteStream, typename ConstBufferSequence>
>inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
> boost::system::error_code& ec)
>{
> return write(s, buffers, transfer_all(), ec);
>}
>
>template <typename SyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition>
>inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write(s, buffers, completion_condition, ec);
> boost::asio::detail::throw_error(ec, "write");
> return bytes_transferred;
>}
>
>
>
>template <typename SyncWriteStream, typename Allocator,
> typename CompletionCondition>
>std::size_t write(SyncWriteStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition, boost::system::error_code& ec)
>{
> std::size_t bytes_transferred = write(s, b.data(), completion_condition, ec);
> b.consume(bytes_transferred);
> return bytes_transferred;
>}
>
>template <typename SyncWriteStream, typename Allocator>
>inline std::size_t write(SyncWriteStream& s,
> boost::asio::basic_streambuf<Allocator>& b)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write(s, b, transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "write");
> return bytes_transferred;
>}
>
>template <typename SyncWriteStream, typename Allocator>
>inline std::size_t write(SyncWriteStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> boost::system::error_code& ec)
>{
> return write(s, b, transfer_all(), ec);
>}
>
>template <typename SyncWriteStream, typename Allocator,
> typename CompletionCondition>
>inline std::size_t write(SyncWriteStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write(s, b, completion_condition, ec);
> boost::asio::detail::throw_error(ec, "write");
> return bytes_transferred;
>}
>
>
>
>namespace detail
>{
> template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
> class write_op
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition, WriteHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> stream_(stream),
> buffers_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_op(const write_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> write_op(write_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> switch (start_ = start)
> {
> case 1:
> buffers_.prepare(this->check_for_completion(ec, total_transferred_));
> for (;;)
> {
> stream_.async_write_some(buffers_,
> static_cast<write_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> buffers_.consume(bytes_transferred);
> buffers_.prepare(this->check_for_completion(ec, total_transferred_));
> if ((!ec && bytes_transferred == 0)
> || buffers_.begin() == buffers_.end())
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncWriteStream& stream_;
> boost::asio::detail::consuming_buffers<
> const_buffer, ConstBufferSequence> buffers_;
> int start_;
> std::size_t total_transferred_;
> WriteHandler handler_;
> };
>
> template <typename AsyncWriteStream,
> typename CompletionCondition, typename WriteHandler>
> class write_op<AsyncWriteStream, boost::asio::mutable_buffers_1,
> CompletionCondition, WriteHandler>
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> write_op(AsyncWriteStream& stream,
> const boost::asio::mutable_buffers_1& buffers,
> CompletionCondition completion_condition,
> WriteHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> stream_(stream),
> buffer_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_op(const write_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffer_(other.buffer_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> write_op(write_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffer_(other.buffer_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> std::size_t n = 0;
> switch (start_ = start)
> {
> case 1:
> n = this->check_for_completion(ec, total_transferred_);
> for (;;)
> {
> stream_.async_write_some(
> boost::asio::buffer(buffer_ + total_transferred_, n),
> static_cast<write_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> if ((!ec && bytes_transferred == 0)
> || (n = this->check_for_completion(ec, total_transferred_)) == 0
> || total_transferred_ == boost::asio::buffer_size(buffer_))
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncWriteStream& stream_;
> boost::asio::mutable_buffer buffer_;
> int start_;
> std::size_t total_transferred_;
> WriteHandler handler_;
> };
>
> template <typename AsyncWriteStream,
> typename CompletionCondition, typename WriteHandler>
> class write_op<AsyncWriteStream, boost::asio::const_buffers_1,
> CompletionCondition, WriteHandler>
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> write_op(AsyncWriteStream& stream,
> const boost::asio::const_buffers_1& buffers,
> CompletionCondition completion_condition,
> WriteHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> stream_(stream),
> buffer_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_op(const write_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffer_(other.buffer_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> write_op(write_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffer_(other.buffer_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> std::size_t n = 0;
> switch (start_ = start)
> {
> case 1:
> n = this->check_for_completion(ec, total_transferred_);
> for (;;)
> {
> stream_.async_write_some(
> boost::asio::buffer(buffer_ + total_transferred_, n),
> static_cast<write_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> if ((!ec && bytes_transferred == 0)
> || (n = this->check_for_completion(ec, total_transferred_)) == 0
> || total_transferred_ == boost::asio::buffer_size(buffer_))
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncWriteStream& stream_;
> boost::asio::const_buffer buffer_;
> int start_;
> std::size_t total_transferred_;
> WriteHandler handler_;
> };
>
> template <typename AsyncWriteStream, typename Elem,
> typename CompletionCondition, typename WriteHandler>
> class write_op<AsyncWriteStream, boost::array<Elem, 2>,
> CompletionCondition, WriteHandler>
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> write_op(AsyncWriteStream& stream, const boost::array<Elem, 2>& buffers,
> CompletionCondition completion_condition, WriteHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> stream_(stream),
> buffers_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_op(const write_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> write_op(write_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> typename boost::asio::detail::dependent_type<Elem,
> boost::array<boost::asio::const_buffer, 2> >::type bufs = {{
> boost::asio::const_buffer(buffers_[0]),
> boost::asio::const_buffer(buffers_[1]) }};
> std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
> std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
> std::size_t n = 0;
> switch (start_ = start)
> {
> case 1:
> n = this->check_for_completion(ec, total_transferred_);
> for (;;)
> {
> bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
> bufs[1] = boost::asio::buffer(
> bufs[1] + (total_transferred_ < buffer_size0
> ? 0 : total_transferred_ - buffer_size0),
> n - boost::asio::buffer_size(bufs[0]));
> stream_.async_write_some(bufs, static_cast<write_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> if ((!ec && bytes_transferred == 0)
> || (n = this->check_for_completion(ec, total_transferred_)) == 0
> || total_transferred_ == buffer_size0 + buffer_size1)
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncWriteStream& stream_;
> boost::array<Elem, 2> buffers_;
> int start_;
> std::size_t total_transferred_;
> WriteHandler handler_;
> };
>
>
>
> template <typename AsyncWriteStream, typename Elem,
> typename CompletionCondition, typename WriteHandler>
> class write_op<AsyncWriteStream, std::array<Elem, 2>,
> CompletionCondition, WriteHandler>
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> write_op(AsyncWriteStream& stream, const std::array<Elem, 2>& buffers,
> CompletionCondition completion_condition, WriteHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> stream_(stream),
> buffers_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_op(const write_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> write_op(write_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> typename boost::asio::detail::dependent_type<Elem,
> std::array<boost::asio::const_buffer, 2> >::type bufs = {{
> boost::asio::const_buffer(buffers_[0]),
> boost::asio::const_buffer(buffers_[1]) }};
> std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
> std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
> std::size_t n = 0;
> switch (start_ = start)
> {
> case 1:
> n = this->check_for_completion(ec, total_transferred_);
> for (;;)
> {
> bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
> bufs[1] = boost::asio::buffer(
> bufs[1] + (total_transferred_ < buffer_size0
> ? 0 : total_transferred_ - buffer_size0),
> n - boost::asio::buffer_size(bufs[0]));
> stream_.async_write_some(bufs, static_cast<write_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> if ((!ec && bytes_transferred == 0)
> || (n = this->check_for_completion(ec, total_transferred_)) == 0
> || total_transferred_ == buffer_size0 + buffer_size1)
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncWriteStream& stream_;
> std::array<Elem, 2> buffers_;
> int start_;
> std::size_t total_transferred_;
> WriteHandler handler_;
> };
>
>
>
> template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
> inline void* asio_handler_allocate(std::size_t size,
> write_op<AsyncWriteStream, ConstBufferSequence,
> CompletionCondition, WriteHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> write_op<AsyncWriteStream, ConstBufferSequence,
> CompletionCondition, WriteHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
> inline bool asio_handler_is_continuation(
> write_op<AsyncWriteStream, ConstBufferSequence,
> CompletionCondition, WriteHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncWriteStream,
> typename ConstBufferSequence, typename CompletionCondition,
> typename WriteHandler>
> inline void asio_handler_invoke(Function& function,
> write_op<AsyncWriteStream, ConstBufferSequence,
> CompletionCondition, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncWriteStream,
> typename ConstBufferSequence, typename CompletionCondition,
> typename WriteHandler>
> inline void asio_handler_invoke(const Function& function,
> write_op<AsyncWriteStream, ConstBufferSequence,
> CompletionCondition, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition,
> WriteHandler&& handler)
>{
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> WriteHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<WriteHandler&&>(handler));
>
> detail::write_op<AsyncWriteStream, ConstBufferSequence,
> CompletionCondition, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> s, buffers, completion_condition, init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
> WriteHandler&& handler)
>{
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> WriteHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<WriteHandler&&>(handler));
>
> detail::write_op<AsyncWriteStream, ConstBufferSequence,
> detail::transfer_all_t, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> s, buffers, transfer_all(), init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>
>
>namespace detail
>{
> template <typename Allocator, typename WriteHandler>
> class write_streambuf_handler
> {
> public:
> write_streambuf_handler(boost::asio::basic_streambuf<Allocator>& streambuf,
> WriteHandler& handler)
> : streambuf_(streambuf),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_streambuf_handler(const write_streambuf_handler& other)
> : streambuf_(other.streambuf_),
> handler_(other.handler_)
> {
> }
>
> write_streambuf_handler(write_streambuf_handler&& other)
> : streambuf_(other.streambuf_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> const std::size_t bytes_transferred)
> {
> streambuf_.consume(bytes_transferred);
> handler_(ec, bytes_transferred);
> }
>
>
> boost::asio::basic_streambuf<Allocator>& streambuf_;
> WriteHandler handler_;
> };
>
> template <typename Allocator, typename WriteHandler>
> inline void* asio_handler_allocate(std::size_t size,
> write_streambuf_handler<Allocator, WriteHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename Allocator, typename WriteHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> write_streambuf_handler<Allocator, WriteHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename Allocator, typename WriteHandler>
> inline bool asio_handler_is_continuation(
> write_streambuf_handler<Allocator, WriteHandler>* this_handler)
> {
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename Allocator, typename WriteHandler>
> inline void asio_handler_invoke(Function& function,
> write_streambuf_handler<Allocator, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename Allocator, typename WriteHandler>
> inline void asio_handler_invoke(const Function& function,
> write_streambuf_handler<Allocator, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>template <typename AsyncWriteStream, typename Allocator,
> typename CompletionCondition, typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write(AsyncWriteStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition,
> WriteHandler&& handler)
>{
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> WriteHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<WriteHandler&&>(handler));
>
> async_write(s, b.data(), completion_condition,
> detail::write_streambuf_handler<Allocator, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> b, init.handler));
>
> return init.result.get();
>}
>
>template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write(AsyncWriteStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> WriteHandler&& handler)
>{
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> WriteHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<WriteHandler&&>(handler));
>
> async_write(s, b.data(), transfer_all(),
> detail::write_streambuf_handler<Allocator, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> b, init.handler));
>
> return init.result.get();
>}
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 766 "/usr/include/boost/asio/impl/write.hpp" 2 3 4
># 619 "/usr/include/boost/asio/write.hpp" 2 3 4
># 30 "/usr/include/boost/asio/buffered_write_stream.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 32 "/usr/include/boost/asio/buffered_write_stream.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 48 "/usr/include/boost/asio/buffered_write_stream.hpp" 3 4
>template <typename Stream>
>class buffered_write_stream
> : private noncopyable
>{
>public:
>
> typedef typename remove_reference<Stream>::type next_layer_type;
>
>
> typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
>
>
>
>
>
> static const std::size_t default_buffer_size = 1024;
>
>
>
> template <typename Arg>
> explicit buffered_write_stream(Arg& a)
> : next_layer_(a),
> storage_(default_buffer_size)
> {
> }
>
>
> template <typename Arg>
> buffered_write_stream(Arg& a, std::size_t buffer_size)
> : next_layer_(a),
> storage_(buffer_size)
> {
> }
>
>
> next_layer_type& next_layer()
> {
> return next_layer_;
> }
>
>
> lowest_layer_type& lowest_layer()
> {
> return next_layer_.lowest_layer();
> }
>
>
> const lowest_layer_type& lowest_layer() const
> {
> return next_layer_.lowest_layer();
> }
>
>
> boost::asio::io_service& get_io_service()
> {
> return next_layer_.get_io_service();
> }
>
>
> void close()
> {
> next_layer_.close();
> }
>
>
> boost::system::error_code close(boost::system::error_code& ec)
> {
> return next_layer_.close(ec);
> }
>
>
>
>
> std::size_t flush()
> {
> std::size_t bytes_written = write(next_layer_,
> buffer(storage_.data(), storage_.size()));
> storage_.consume(bytes_written);
> return bytes_written;
> }
>
>
>
>
> std::size_t flush(boost::system::error_code& ec)
> {
> std::size_t bytes_written = write(next_layer_,
> buffer(storage_.data(), storage_.size()),
> transfer_all(), ec);
> storage_.consume(bytes_written);
> return bytes_written;
> }
>
> template <typename WriteHandler>
> class flush_handler
> {
> public:
> flush_handler(boost::asio::io_service& io_service,
> detail::buffered_stream_storage& storage, WriteHandler handler)
> : io_service_(io_service),
> storage_(storage),
> handler_(handler)
> {
> }
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_written)
> {
> storage_.consume(bytes_written);
> io_service_.dispatch(detail::bind_handler(handler_, ec, bytes_written));
> }
>
> private:
> boost::asio::io_service& io_service_;
> detail::buffered_stream_storage& storage_;
> WriteHandler handler_;
> };
>
>
> template <typename WriteHandler>
> void async_flush(WriteHandler handler)
> {
> async_write(next_layer_, buffer(storage_.data(), storage_.size()),
> flush_handler<WriteHandler>(get_io_service(), storage_, handler));
> }
>
>
>
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers)
> {
> if (boost::asio::buffer_size(buffers) == 0)
> return 0;
>
> if (storage_.size() == storage_.capacity())
> flush();
>
> return copy(buffers);
> }
>
>
>
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> ec = boost::system::error_code();
>
> if (boost::asio::buffer_size(buffers) == 0)
> return 0;
>
> if (storage_.size() == storage_.capacity() && !flush(ec))
> return 0;
>
> return copy(buffers);
> }
>
> template <typename ConstBufferSequence, typename WriteHandler>
> class write_some_handler
> {
> public:
> write_some_handler(boost::asio::io_service& io_service,
> detail::buffered_stream_storage& storage,
> const ConstBufferSequence& buffers, WriteHandler handler)
> : io_service_(io_service),
> storage_(storage),
> buffers_(buffers),
> handler_(handler)
> {
> }
>
> void operator()(const boost::system::error_code& ec, std::size_t)
> {
> if (ec)
> {
> std::size_t length = 0;
> io_service_.dispatch(detail::bind_handler(handler_, ec, length));
> }
> else
> {
> std::size_t orig_size = storage_.size();
> std::size_t space_avail = storage_.capacity() - orig_size;
> std::size_t bytes_avail = boost::asio::buffer_size(buffers_);
> std::size_t length = bytes_avail < space_avail
> ? bytes_avail : space_avail;
> storage_.resize(orig_size + length);
> std::size_t bytes_copied = boost::asio::buffer_copy(
> storage_.data() + orig_size, buffers_, length);
>
> io_service_.dispatch(detail::bind_handler(handler_, ec, bytes_copied));
> }
> }
>
> private:
> boost::asio::io_service& io_service_;
> detail::buffered_stream_storage& storage_;
> ConstBufferSequence buffers_;
> WriteHandler handler_;
> };
>
>
>
> template <typename ConstBufferSequence, typename WriteHandler>
> void async_write_some(const ConstBufferSequence& buffers,
> WriteHandler handler)
> {
> if (boost::asio::buffer_size(buffers) == 0)
> {
> get_io_service().post(detail::bind_handler(
> handler, boost::system::error_code(), 0));
> }
> else if (storage_.size() == storage_.capacity())
> {
> async_flush(write_some_handler<ConstBufferSequence, WriteHandler>(
> get_io_service(), storage_, buffers, handler));
> }
> else
> {
> std::size_t bytes_copied = copy(buffers);
> get_io_service().post(detail::bind_handler(
> handler, boost::system::error_code(), bytes_copied));
> }
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers)
> {
> return next_layer_.read_some(buffers);
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return next_layer_.read_some(buffers, ec);
> }
>
>
>
> template <typename MutableBufferSequence, typename ReadHandler>
> void async_read_some(const MutableBufferSequence& buffers,
> ReadHandler handler)
> {
> next_layer_.async_read_some(buffers, handler);
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t peek(const MutableBufferSequence& buffers)
> {
> return next_layer_.peek(buffers);
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t peek(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return next_layer_.peek(buffers, ec);
> }
>
>
> std::size_t in_avail()
> {
> return next_layer_.in_avail();
> }
>
>
> std::size_t in_avail(boost::system::error_code& ec)
> {
> return next_layer_.in_avail(ec);
> }
>
>private:
>
>
> template <typename ConstBufferSequence>
> std::size_t copy(const ConstBufferSequence& buffers)
> {
> std::size_t orig_size = storage_.size();
> std::size_t space_avail = storage_.capacity() - orig_size;
> std::size_t bytes_avail = boost::asio::buffer_size(buffers);
> std::size_t length = bytes_avail < space_avail ? bytes_avail : space_avail;
> storage_.resize(orig_size + length);
> return boost::asio::buffer_copy(
> storage_.data() + orig_size, buffers, length);
> }
>
>
> Stream next_layer_;
>
>
> detail::buffered_stream_storage storage_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 353 "/usr/include/boost/asio/buffered_write_stream.hpp" 2 3 4
># 22 "/usr/include/boost/asio/buffered_stream.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/buffered_stream.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 44 "/usr/include/boost/asio/buffered_stream.hpp" 3 4
>template <typename Stream>
>class buffered_stream
> : private noncopyable
>{
>public:
>
> typedef typename remove_reference<Stream>::type next_layer_type;
>
>
> typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
>
>
> template <typename Arg>
> explicit buffered_stream(Arg& a)
> : inner_stream_impl_(a),
> stream_impl_(inner_stream_impl_)
> {
> }
>
>
> template <typename Arg>
> explicit buffered_stream(Arg& a, std::size_t read_buffer_size,
> std::size_t write_buffer_size)
> : inner_stream_impl_(a, write_buffer_size),
> stream_impl_(inner_stream_impl_, read_buffer_size)
> {
> }
>
>
> next_layer_type& next_layer()
> {
> return stream_impl_.next_layer().next_layer();
> }
>
>
> lowest_layer_type& lowest_layer()
> {
> return stream_impl_.lowest_layer();
> }
>
>
> const lowest_layer_type& lowest_layer() const
> {
> return stream_impl_.lowest_layer();
> }
>
>
> boost::asio::io_service& get_io_service()
> {
> return stream_impl_.get_io_service();
> }
>
>
> void close()
> {
> stream_impl_.close();
> }
>
>
> boost::system::error_code close(boost::system::error_code& ec)
> {
> return stream_impl_.close(ec);
> }
>
>
>
>
> std::size_t flush()
> {
> return stream_impl_.next_layer().flush();
> }
>
>
>
>
> std::size_t flush(boost::system::error_code& ec)
> {
> return stream_impl_.next_layer().flush(ec);
> }
>
>
> template <typename WriteHandler>
> void async_flush(WriteHandler handler)
> {
> return stream_impl_.next_layer().async_flush(handler);
> }
>
>
>
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers)
> {
> return stream_impl_.write_some(buffers);
> }
>
>
>
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return stream_impl_.write_some(buffers, ec);
> }
>
>
>
> template <typename ConstBufferSequence, typename WriteHandler>
> void async_write_some(const ConstBufferSequence& buffers,
> WriteHandler handler)
> {
> stream_impl_.async_write_some(buffers, handler);
> }
>
>
>
> std::size_t fill()
> {
> return stream_impl_.fill();
> }
>
>
>
> std::size_t fill(boost::system::error_code& ec)
> {
> return stream_impl_.fill(ec);
> }
>
>
> template <typename ReadHandler>
> void async_fill(ReadHandler handler)
> {
> stream_impl_.async_fill(handler);
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers)
> {
> return stream_impl_.read_some(buffers);
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return stream_impl_.read_some(buffers, ec);
> }
>
>
>
> template <typename MutableBufferSequence, typename ReadHandler>
> void async_read_some(const MutableBufferSequence& buffers,
> ReadHandler handler)
> {
> stream_impl_.async_read_some(buffers, handler);
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t peek(const MutableBufferSequence& buffers)
> {
> return stream_impl_.peek(buffers);
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t peek(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return stream_impl_.peek(buffers, ec);
> }
>
>
> std::size_t in_avail()
> {
> return stream_impl_.in_avail();
> }
>
>
> std::size_t in_avail(boost::system::error_code& ec)
> {
> return stream_impl_.in_avail(ec);
> }
>
>private:
>
> typedef buffered_write_stream<Stream> write_stream_type;
> write_stream_type inner_stream_impl_;
>
>
> typedef buffered_read_stream<write_stream_type&> read_stream_type;
> read_stream_type stream_impl_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 247 "/usr/include/boost/asio/buffered_stream.hpp" 2 3 4
># 39 "/usr/include/boost/asio.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/buffers_iterator.hpp" 1 3 4
># 19 "/usr/include/boost/asio/buffers_iterator.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/buffers_iterator.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/buffers_iterator.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail
>{
> template <bool IsMutable>
> struct buffers_iterator_types_helper;
>
> template <>
> struct buffers_iterator_types_helper<false>
> {
> typedef const_buffer buffer_type;
> template <typename ByteType>
> struct byte_type
> {
> typedef typename add_const<ByteType>::type type;
> };
> };
>
> template <>
> struct buffers_iterator_types_helper<true>
> {
> typedef mutable_buffer buffer_type;
> template <typename ByteType>
> struct byte_type
> {
> typedef ByteType type;
> };
> };
>
> template <typename BufferSequence, typename ByteType>
> struct buffers_iterator_types
> {
> enum
> {
> is_mutable = is_convertible<
> typename BufferSequence::value_type,
> mutable_buffer>::value
> };
> typedef buffers_iterator_types_helper<is_mutable> helper;
> typedef typename helper::buffer_type buffer_type;
> typedef typename helper::template byte_type<ByteType>::type byte_type;
> };
>}
>
>
>template <typename BufferSequence, typename ByteType = char>
>class buffers_iterator
>{
>private:
> typedef typename detail::buffers_iterator_types<
> BufferSequence, ByteType>::buffer_type buffer_type;
>
>public:
>
> typedef std::ptrdiff_t difference_type;
>
>
> typedef ByteType value_type;
># 96 "/usr/include/boost/asio/buffers_iterator.hpp" 3 4
> typedef typename detail::buffers_iterator_types<
> BufferSequence, ByteType>::byte_type* pointer;
># 109 "/usr/include/boost/asio/buffers_iterator.hpp" 3 4
> typedef typename detail::buffers_iterator_types<
> BufferSequence, ByteType>::byte_type& reference;
>
>
>
> typedef std::random_access_iterator_tag iterator_category;
>
>
> buffers_iterator()
> : current_buffer_(),
> current_buffer_position_(0),
> begin_(),
> current_(),
> end_(),
> position_(0)
> {
> }
>
>
> static buffers_iterator begin(const BufferSequence& buffers)
>
>
>
> {
> buffers_iterator new_iter;
> new_iter.begin_ = buffers.begin();
> new_iter.current_ = buffers.begin();
> new_iter.end_ = buffers.end();
> while (new_iter.current_ != new_iter.end_)
> {
> new_iter.current_buffer_ = *new_iter.current_;
> if (boost::asio::buffer_size(new_iter.current_buffer_) > 0)
> break;
> ++new_iter.current_;
> }
> return new_iter;
> }
>
>
> static buffers_iterator end(const BufferSequence& buffers)
>
>
>
> {
> buffers_iterator new_iter;
> new_iter.begin_ = buffers.begin();
> new_iter.current_ = buffers.begin();
> new_iter.end_ = buffers.end();
> while (new_iter.current_ != new_iter.end_)
> {
> buffer_type buffer = *new_iter.current_;
> new_iter.position_ += boost::asio::buffer_size(buffer);
> ++new_iter.current_;
> }
> return new_iter;
> }
>
>
> reference operator*() const
> {
> return dereference();
> }
>
>
> pointer operator->() const
> {
> return &dereference();
> }
>
>
> reference operator[](std::ptrdiff_t difference) const
> {
> buffers_iterator tmp(*this);
> tmp.advance(difference);
> return *tmp;
> }
>
>
> buffers_iterator& operator++()
> {
> increment();
> return *this;
> }
>
>
> buffers_iterator operator++(int)
> {
> buffers_iterator tmp(*this);
> ++*this;
> return tmp;
> }
>
>
> buffers_iterator& operator--()
> {
> decrement();
> return *this;
> }
>
>
> buffers_iterator operator--(int)
> {
> buffers_iterator tmp(*this);
> --*this;
> return tmp;
> }
>
>
> buffers_iterator& operator+=(std::ptrdiff_t difference)
> {
> advance(difference);
> return *this;
> }
>
>
> buffers_iterator& operator-=(std::ptrdiff_t difference)
> {
> advance(-difference);
> return *this;
> }
>
>
> friend buffers_iterator operator+(const buffers_iterator& iter,
> std::ptrdiff_t difference)
> {
> buffers_iterator tmp(iter);
> tmp.advance(difference);
> return tmp;
> }
>
>
> friend buffers_iterator operator+(std::ptrdiff_t difference,
> const buffers_iterator& iter)
> {
> buffers_iterator tmp(iter);
> tmp.advance(difference);
> return tmp;
> }
>
>
> friend buffers_iterator operator-(const buffers_iterator& iter,
> std::ptrdiff_t difference)
> {
> buffers_iterator tmp(iter);
> tmp.advance(-difference);
> return tmp;
> }
>
>
> friend std::ptrdiff_t operator-(const buffers_iterator& a,
> const buffers_iterator& b)
> {
> return b.distance_to(a);
> }
>
>
> friend bool operator==(const buffers_iterator& a, const buffers_iterator& b)
> {
> return a.equal(b);
> }
>
>
> friend bool operator!=(const buffers_iterator& a, const buffers_iterator& b)
> {
> return !a.equal(b);
> }
>
>
> friend bool operator<(const buffers_iterator& a, const buffers_iterator& b)
> {
> return a.distance_to(b) > 0;
> }
>
>
> friend bool operator<=(const buffers_iterator& a, const buffers_iterator& b)
> {
> return !(b < a);
> }
>
>
> friend bool operator>(const buffers_iterator& a, const buffers_iterator& b)
> {
> return b < a;
> }
>
>
> friend bool operator>=(const buffers_iterator& a, const buffers_iterator& b)
> {
> return !(a < b);
> }
>
>private:
>
> reference dereference() const
> {
> return buffer_cast<pointer>(current_buffer_)[current_buffer_position_];
> }
>
>
> bool equal(const buffers_iterator& other) const
> {
> return position_ == other.position_;
> }
>
>
> void increment()
> {
> ((void)0);
> ++position_;
>
>
> ++current_buffer_position_;
> if (current_buffer_position_ != boost::asio::buffer_size(current_buffer_))
> return;
>
>
> ++current_;
> current_buffer_position_ = 0;
> while (current_ != end_)
> {
> current_buffer_ = *current_;
> if (boost::asio::buffer_size(current_buffer_) > 0)
> return;
> ++current_;
> }
> }
>
>
> void decrement()
> {
> ((void)0);
> --position_;
>
>
> if (current_buffer_position_ != 0)
> {
> --current_buffer_position_;
> return;
> }
>
>
> typename BufferSequence::const_iterator iter = current_;
> while (iter != begin_)
> {
> --iter;
> buffer_type buffer = *iter;
> std::size_t buffer_size = boost::asio::buffer_size(buffer);
> if (buffer_size > 0)
> {
> current_ = iter;
> current_buffer_ = buffer;
> current_buffer_position_ = buffer_size - 1;
> return;
> }
> }
> }
>
>
> void advance(std::ptrdiff_t n)
> {
> if (n > 0)
> {
> ((void)0);
> for (;;)
> {
> std::ptrdiff_t current_buffer_balance
> = boost::asio::buffer_size(current_buffer_)
> - current_buffer_position_;
>
>
> if (current_buffer_balance > n)
> {
> position_ += n;
> current_buffer_position_ += n;
> return;
> }
>
>
> n -= current_buffer_balance;
> position_ += current_buffer_balance;
>
>
>
> if (++current_ == end_)
> {
> ((void)0);
> current_buffer_ = buffer_type();
> current_buffer_position_ = 0;
> return;
> }
> current_buffer_ = *current_;
> current_buffer_position_ = 0;
> }
> }
> else if (n < 0)
> {
> std::size_t abs_n = -n;
> ((void)0);
> for (;;)
> {
>
> if (current_buffer_position_ >= abs_n)
> {
> position_ -= abs_n;
> current_buffer_position_ -= abs_n;
> return;
> }
>
>
> abs_n -= current_buffer_position_;
> position_ -= current_buffer_position_;
>
>
> if (current_ == begin_)
> {
> ((void)0);
> current_buffer_position_ = 0;
> return;
> }
>
>
> typename BufferSequence::const_iterator iter = current_;
> while (iter != begin_)
> {
> --iter;
> buffer_type buffer = *iter;
> std::size_t buffer_size = boost::asio::buffer_size(buffer);
> if (buffer_size > 0)
> {
> current_ = iter;
> current_buffer_ = buffer;
> current_buffer_position_ = buffer_size;
> break;
> }
> }
> }
> }
> }
>
>
> std::ptrdiff_t distance_to(const buffers_iterator& other) const
> {
> return other.position_ - position_;
> }
>
> buffer_type current_buffer_;
> std::size_t current_buffer_position_;
> typename BufferSequence::const_iterator begin_;
> typename BufferSequence::const_iterator current_;
> typename BufferSequence::const_iterator end_;
> std::size_t position_;
>};
>
>
>template <typename BufferSequence>
>inline buffers_iterator<BufferSequence> buffers_begin(
> const BufferSequence& buffers)
>{
> return buffers_iterator<BufferSequence>::begin(buffers);
>}
>
>
>template <typename BufferSequence>
>inline buffers_iterator<BufferSequence> buffers_end(
> const BufferSequence& buffers)
>{
> return buffers_iterator<BufferSequence>::end(buffers);
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 482 "/usr/include/boost/asio/buffers_iterator.hpp" 2 3 4
># 42 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/connect.hpp" 1 3 4
># 23 "/usr/include/boost/asio/connect.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 24 "/usr/include/boost/asio/connect.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 64 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol, typename SocketService, typename Iterator>
>Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin);
># 101 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol, typename SocketService, typename Iterator>
>Iterator connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, boost::system::error_code& ec);
># 133 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol, typename SocketService, typename Iterator>
>Iterator connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, Iterator end);
># 170 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol, typename SocketService, typename Iterator>
>Iterator connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, Iterator end, boost::system::error_code& ec);
># 233 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol, typename SocketService,
> typename Iterator, typename ConnectCondition>
>Iterator connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, ConnectCondition connect_condition);
># 305 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol, typename SocketService,
> typename Iterator, typename ConnectCondition>
>Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
> ConnectCondition connect_condition, boost::system::error_code& ec);
># 367 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol, typename SocketService,
> typename Iterator, typename ConnectCondition>
>Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
> Iterator end, ConnectCondition connect_condition);
># 437 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol, typename SocketService,
> typename Iterator, typename ConnectCondition>
>Iterator connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, Iterator end, ConnectCondition connect_condition,
> boost::system::error_code& ec);
># 518 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol, typename SocketService,
> typename Iterator, typename ComposedConnectHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
>
>async_connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, ComposedConnectHandler&& handler);
># 589 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol, typename SocketService,
> typename Iterator, typename ComposedConnectHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
>
>async_connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, Iterator end,
> ComposedConnectHandler&& handler);
># 699 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol, typename SocketService, typename Iterator,
> typename ConnectCondition, typename ComposedConnectHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
>
>async_connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
> ConnectCondition connect_condition,
> ComposedConnectHandler&& handler);
># 808 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol, typename SocketService, typename Iterator,
> typename ConnectCondition, typename ComposedConnectHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
>
>async_connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, Iterator end, ConnectCondition connect_condition,
> ComposedConnectHandler&& handler);
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 822 "/usr/include/boost/asio/connect.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/connect.hpp" 1 3 4
># 27 "/usr/include/boost/asio/impl/connect.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/impl/connect.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail
>{
> struct default_connect_condition
> {
> template <typename Iterator>
> Iterator operator()(const boost::system::error_code&, Iterator next)
> {
> return next;
> }
> };
>}
>
>template <typename Protocol, typename SocketService, typename Iterator>
>Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin)
>{
> boost::system::error_code ec;
> Iterator result = connect(s, begin, ec);
> boost::asio::detail::throw_error(ec, "connect");
> return result;
>}
>
>template <typename Protocol, typename SocketService, typename Iterator>
>inline Iterator connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, boost::system::error_code& ec)
>{
> return connect(s, begin, Iterator(), detail::default_connect_condition(), ec);
>}
>
>template <typename Protocol, typename SocketService, typename Iterator>
>Iterator connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, Iterator end)
>{
> boost::system::error_code ec;
> Iterator result = connect(s, begin, end, ec);
> boost::asio::detail::throw_error(ec, "connect");
> return result;
>}
>
>template <typename Protocol, typename SocketService, typename Iterator>
>inline Iterator connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, Iterator end, boost::system::error_code& ec)
>{
> return connect(s, begin, end, detail::default_connect_condition(), ec);
>}
>
>template <typename Protocol, typename SocketService,
> typename Iterator, typename ConnectCondition>
>Iterator connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, ConnectCondition connect_condition)
>{
> boost::system::error_code ec;
> Iterator result = connect(s, begin, connect_condition, ec);
> boost::asio::detail::throw_error(ec, "connect");
> return result;
>}
>
>template <typename Protocol, typename SocketService,
> typename Iterator, typename ConnectCondition>
>inline Iterator connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, ConnectCondition connect_condition,
> boost::system::error_code& ec)
>{
> return connect(s, begin, Iterator(), connect_condition, ec);
>}
>
>template <typename Protocol, typename SocketService,
> typename Iterator, typename ConnectCondition>
>Iterator connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, Iterator end, ConnectCondition connect_condition)
>{
> boost::system::error_code ec;
> Iterator result = connect(s, begin, end, connect_condition, ec);
> boost::asio::detail::throw_error(ec, "connect");
> return result;
>}
>
>template <typename Protocol, typename SocketService,
> typename Iterator, typename ConnectCondition>
>Iterator connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, Iterator end, ConnectCondition connect_condition,
> boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
>
> for (Iterator iter = begin; iter != end; ++iter)
> {
> iter = connect_condition(ec, iter);
> if (iter != end)
> {
> s.close(ec);
> s.connect(*iter, ec);
> if (!ec)
> return iter;
> }
> }
>
> if (!ec)
> ec = boost::asio::error::not_found;
>
> return end;
>}
>
>namespace detail
>{
>
> template <typename ConnectCondition>
> class base_from_connect_condition
> {
> protected:
> explicit base_from_connect_condition(
> const ConnectCondition& connect_condition)
> : connect_condition_(connect_condition)
> {
> }
>
> template <typename Iterator>
> void check_condition(const boost::system::error_code& ec,
> Iterator& iter, Iterator& end)
> {
> if (iter != end)
> iter = connect_condition_(ec, static_cast<const Iterator&>(iter));
> }
>
> private:
> ConnectCondition connect_condition_;
> };
>
>
>
> template <>
> class base_from_connect_condition<default_connect_condition>
> {
> protected:
> explicit base_from_connect_condition(const default_connect_condition&)
> {
> }
>
> template <typename Iterator>
> void check_condition(const boost::system::error_code&, Iterator&, Iterator&)
> {
> }
> };
>
> template <typename Protocol, typename SocketService, typename Iterator,
> typename ConnectCondition, typename ComposedConnectHandler>
> class connect_op : base_from_connect_condition<ConnectCondition>
> {
> public:
> connect_op(basic_socket<Protocol, SocketService>& sock,
> const Iterator& begin, const Iterator& end,
> const ConnectCondition& connect_condition,
> ComposedConnectHandler& handler)
> : base_from_connect_condition<ConnectCondition>(connect_condition),
> socket_(sock),
> iter_(begin),
> end_(end),
> start_(0),
> handler_(static_cast<ComposedConnectHandler&&>(handler))
> {
> }
>
>
> connect_op(const connect_op& other)
> : base_from_connect_condition<ConnectCondition>(other),
> socket_(other.socket_),
> iter_(other.iter_),
> end_(other.end_),
> start_(other.start_),
> handler_(other.handler_)
> {
> }
>
> connect_op(connect_op&& other)
> : base_from_connect_condition<ConnectCondition>(other),
> socket_(other.socket_),
> iter_(other.iter_),
> end_(other.end_),
> start_(other.start_),
> handler_(static_cast<ComposedConnectHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(boost::system::error_code ec, int start = 0)
> {
> switch (start_ = start)
> {
> case 1:
> for (;;)
> {
> this->check_condition(ec, iter_, end_);
>
> if (iter_ != end_)
> {
> socket_.close(ec);
> socket_.async_connect(*iter_,
> static_cast<connect_op&&>(*this));
> return;
> }
>
> if (start)
> {
> ec = boost::asio::error::not_found;
> socket_.get_io_service().post(detail::bind_handler(*this, ec));
> return;
> }
>
> default:
>
> if (iter_ == end_)
> break;
>
> if (!socket_.is_open())
> {
> ec = boost::asio::error::operation_aborted;
> break;
> }
>
> if (!ec)
> break;
>
> ++iter_;
> }
>
> handler_(static_cast<const boost::system::error_code&>(ec),
> static_cast<const Iterator&>(iter_));
> }
> }
>
>
> basic_socket<Protocol, SocketService>& socket_;
> Iterator iter_;
> Iterator end_;
> int start_;
> ComposedConnectHandler handler_;
> };
>
> template <typename Protocol, typename SocketService, typename Iterator,
> typename ConnectCondition, typename ComposedConnectHandler>
> inline void* asio_handler_allocate(std::size_t size,
> connect_op<Protocol, SocketService, Iterator,
> ConnectCondition, ComposedConnectHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename Protocol, typename SocketService, typename Iterator,
> typename ConnectCondition, typename ComposedConnectHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> connect_op<Protocol, SocketService, Iterator,
> ConnectCondition, ComposedConnectHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename Protocol, typename SocketService, typename Iterator,
> typename ConnectCondition, typename ComposedConnectHandler>
> inline bool asio_handler_is_continuation(
> connect_op<Protocol, SocketService, Iterator,
> ConnectCondition, ComposedConnectHandler>* this_handler)
> {
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename Protocol,
> typename SocketService, typename Iterator,
> typename ConnectCondition, typename ComposedConnectHandler>
> inline void asio_handler_invoke(Function& function,
> connect_op<Protocol, SocketService, Iterator,
> ConnectCondition, ComposedConnectHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename Protocol,
> typename SocketService, typename Iterator,
> typename ConnectCondition, typename ComposedConnectHandler>
> inline void asio_handler_invoke(const Function& function,
> connect_op<Protocol, SocketService, Iterator,
> ConnectCondition, ComposedConnectHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>template <typename Protocol, typename SocketService,
> typename Iterator, typename ComposedConnectHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
>
>async_connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, ComposedConnectHandler&& handler)
>{
>
>
> typedef typename handler_type<ComposedConnectHandler, void(boost::system::error_code, Iterator)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const Iterator*>(0))) == 1, "ComposedConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const Iterator>()), char(0))>
> type_check;
>
> detail::async_result_init<ComposedConnectHandler,
> void (boost::system::error_code, Iterator)> init(
> static_cast<ComposedConnectHandler&&>(handler));
>
> detail::connect_op<Protocol, SocketService, Iterator,
> detail::default_connect_condition, typename handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type
> >(s,
> begin, Iterator(), detail::default_connect_condition(), init.handler)(
> boost::system::error_code(), 1);
>
> return init.result.get();
>}
>
>template <typename Protocol, typename SocketService,
> typename Iterator, typename ComposedConnectHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
>
>async_connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, Iterator end,
> ComposedConnectHandler&& handler)
>{
>
>
> typedef typename handler_type<ComposedConnectHandler, void(boost::system::error_code, Iterator)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const Iterator*>(0))) == 1, "ComposedConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const Iterator>()), char(0))>
> type_check;
>
> detail::async_result_init<ComposedConnectHandler,
> void (boost::system::error_code, Iterator)> init(
> static_cast<ComposedConnectHandler&&>(handler));
>
> detail::connect_op<Protocol, SocketService, Iterator,
> detail::default_connect_condition, typename handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type
> >(s,
> begin, end, detail::default_connect_condition(), init.handler)(
> boost::system::error_code(), 1);
>
> return init.result.get();
>}
>
>template <typename Protocol, typename SocketService, typename Iterator,
> typename ConnectCondition, typename ComposedConnectHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
>
>async_connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, ConnectCondition connect_condition,
> ComposedConnectHandler&& handler)
>{
>
>
> typedef typename handler_type<ComposedConnectHandler, void(boost::system::error_code, Iterator)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const Iterator*>(0))) == 1, "ComposedConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const Iterator>()), char(0))>
> type_check;
>
> detail::async_result_init<ComposedConnectHandler,
> void (boost::system::error_code, Iterator)> init(
> static_cast<ComposedConnectHandler&&>(handler));
>
> detail::connect_op<Protocol, SocketService, Iterator,
> ConnectCondition, typename handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type
> >(s,
> begin, Iterator(), connect_condition, init.handler)(
> boost::system::error_code(), 1);
>
> return init.result.get();
>}
>
>template <typename Protocol, typename SocketService, typename Iterator,
> typename ConnectCondition, typename ComposedConnectHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
>
>async_connect(basic_socket<Protocol, SocketService>& s,
> Iterator begin, Iterator end, ConnectCondition connect_condition,
> ComposedConnectHandler&& handler)
>{
>
>
> typedef typename handler_type<ComposedConnectHandler, void(boost::system::error_code, Iterator)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const Iterator*>(0))) == 1, "ComposedConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const Iterator>()), char(0))>
> type_check;
>
> detail::async_result_init<ComposedConnectHandler,
> void (boost::system::error_code, Iterator)> init(
> static_cast<ComposedConnectHandler&&>(handler));
>
> detail::connect_op<Protocol, SocketService, Iterator,
> ConnectCondition, typename handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type
> >(s,
> begin, end, connect_condition, init.handler)(
> boost::system::error_code(), 1);
>
> return init.result.get();
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 429 "/usr/include/boost/asio/impl/connect.hpp" 2 3 4
># 824 "/usr/include/boost/asio/connect.hpp" 2 3 4
># 44 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/coroutine.hpp" 1 3 4
># 14 "/usr/include/boost/asio/coroutine.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>class coroutine_ref;
>
>}
># 242 "/usr/include/boost/asio/coroutine.hpp" 3 4
>class coroutine
>{
>public:
>
> coroutine() : value_(0) {}
>
>
> bool is_child() const { return value_ < 0; }
>
>
> bool is_parent() const { return !is_child(); }
>
>
> bool is_complete() const { return value_ == -1; }
>
>private:
> friend class detail::coroutine_ref;
> int value_;
>};
>
>
>namespace detail {
>
>class coroutine_ref
>{
>public:
> coroutine_ref(coroutine& c) : value_(c.value_), modified_(false) {}
> coroutine_ref(coroutine* c) : value_(c->value_), modified_(false) {}
> ~coroutine_ref() { if (!modified_) value_ = -1; }
> operator int() const { return value_; }
> int& operator=(int v) { modified_ = true; return value_ = v; }
>private:
> void operator=(const coroutine_ref&);
> int& value_;
> bool modified_;
>};
>
>}
>}
>}
># 45 "/usr/include/boost/asio.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/generic/basic_endpoint.hpp" 1 3 4
># 19 "/usr/include/boost/asio/generic/basic_endpoint.hpp" 3 4
># 1 "/usr/include/boost/asio/generic/detail/endpoint.hpp" 1 3 4
># 20 "/usr/include/boost/asio/generic/detail/endpoint.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 21 "/usr/include/boost/asio/generic/detail/endpoint.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 24 "/usr/include/boost/asio/generic/detail/endpoint.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace generic {
>namespace detail {
>
>
>class endpoint
>{
>public:
>
> inline endpoint();
>
>
> inline endpoint(const void* sock_addr,
> std::size_t sock_addr_size, int sock_protocol);
>
>
> endpoint(const endpoint& other)
> : data_(other.data_),
> size_(other.size_),
> protocol_(other.protocol_)
> {
> }
>
>
> endpoint& operator=(const endpoint& other)
> {
> data_ = other.data_;
> size_ = other.size_;
> protocol_ = other.protocol_;
> return *this;
> }
>
>
> int family() const
> {
> return data_.base.sa_family;
> }
>
>
> int protocol() const
> {
> return protocol_;
> }
>
>
> boost::asio::detail::socket_addr_type* data()
> {
> return &data_.base;
> }
>
>
> const boost::asio::detail::socket_addr_type* data() const
> {
> return &data_.base;
> }
>
>
> std::size_t size() const
> {
> return size_;
> }
>
>
> inline void resize(std::size_t size);
>
>
> std::size_t capacity() const
> {
> return sizeof(boost::asio::detail::sockaddr_storage_type);
> }
>
>
> inline friend bool operator==(
> const endpoint& e1, const endpoint& e2);
>
>
> inline friend bool operator<(
> const endpoint& e1, const endpoint& e2);
>
>private:
>
> union data_union
> {
> boost::asio::detail::socket_addr_type base;
> boost::asio::detail::sockaddr_storage_type generic;
> } data_;
>
>
> std::size_t size_;
>
>
> int protocol_;
>
>
> inline void init(const void* sock_addr,
> std::size_t sock_addr_size, int sock_protocol);
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 130 "/usr/include/boost/asio/generic/detail/endpoint.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/generic/detail/impl/endpoint.ipp" 1 3 4
># 20 "/usr/include/boost/asio/generic/detail/impl/endpoint.ipp" 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 21 "/usr/include/boost/asio/generic/detail/impl/endpoint.ipp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/generic/detail/endpoint.hpp" 1 3 4
># 27 "/usr/include/boost/asio/generic/detail/impl/endpoint.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 29 "/usr/include/boost/asio/generic/detail/impl/endpoint.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace generic {
>namespace detail {
>
>endpoint::endpoint()
>{
> init(0, 0, 0);
>}
>
>endpoint::endpoint(const void* sock_addr,
> std::size_t sock_addr_size, int sock_protocol)
>{
> init(sock_addr, sock_addr_size, sock_protocol);
>}
>
>void endpoint::resize(std::size_t new_size)
>{
> if (new_size > sizeof(boost::asio::detail::sockaddr_storage_type))
> {
> boost::system::error_code ec(boost::asio::error::invalid_argument);
> boost::asio::detail::throw_error(ec);
> }
> else
> {
> size_ = new_size;
> protocol_ = 0;
> }
>}
>
>bool operator==(const endpoint& e1, const endpoint& e2)
>{
> using namespace std;
> return e1.size() == e2.size() && memcmp(e1.data(), e2.data(), e1.size()) == 0;
>}
>
>bool operator<(const endpoint& e1, const endpoint& e2)
>{
> if (e1.protocol() < e2.protocol())
> return true;
>
> if (e1.protocol() > e2.protocol())
> return false;
>
> using namespace std;
> std::size_t compare_size = e1.size() < e2.size() ? e1.size() : e2.size();
> int compare_result = memcmp(e1.data(), e2.data(), compare_size);
>
> if (compare_result < 0)
> return true;
>
> if (compare_result > 0)
> return false;
>
> return e1.size() < e2.size();
>}
>
>void endpoint::init(const void* sock_addr,
> std::size_t sock_addr_size, int sock_protocol)
>{
> if (sock_addr_size > sizeof(boost::asio::detail::sockaddr_storage_type))
> {
> boost::system::error_code ec(boost::asio::error::invalid_argument);
> boost::asio::detail::throw_error(ec);
> }
>
> using namespace std;
> memset(&data_.generic, 0, sizeof(boost::asio::detail::sockaddr_storage_type));
> memcpy(&data_.generic, sock_addr, sock_addr_size);
>
> size_ = sock_addr_size;
> protocol_ = sock_protocol;
>}
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 110 "/usr/include/boost/asio/generic/detail/impl/endpoint.ipp" 2 3 4
># 133 "/usr/include/boost/asio/generic/detail/endpoint.hpp" 2 3 4
># 20 "/usr/include/boost/asio/generic/basic_endpoint.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/generic/basic_endpoint.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace generic {
># 42 "/usr/include/boost/asio/generic/basic_endpoint.hpp" 3 4
>template <typename Protocol>
>class basic_endpoint
>{
>public:
>
> typedef Protocol protocol_type;
>
>
>
>
>
>
> typedef boost::asio::detail::socket_addr_type data_type;
>
>
>
> basic_endpoint()
> {
> }
>
>
> basic_endpoint(const void* socket_address,
> std::size_t socket_address_size, int socket_protocol = 0)
> : impl_(socket_address, socket_address_size, socket_protocol)
> {
> }
>
>
> template <typename Endpoint>
> basic_endpoint(const Endpoint& endpoint)
> : impl_(endpoint.data(), endpoint.size(), endpoint.protocol().protocol())
> {
> }
>
>
> basic_endpoint(const basic_endpoint& other)
> : impl_(other.impl_)
> {
> }
>
>
>
> basic_endpoint(basic_endpoint&& other)
> : impl_(other.impl_)
> {
> }
>
>
>
> basic_endpoint& operator=(const basic_endpoint& other)
> {
> impl_ = other.impl_;
> return *this;
> }
>
>
>
> basic_endpoint& operator=(basic_endpoint&& other)
> {
> impl_ = other.impl_;
> return *this;
> }
>
>
>
> protocol_type protocol() const
> {
> return protocol_type(impl_.family(), impl_.protocol());
> }
>
>
> data_type* data()
> {
> return impl_.data();
> }
>
>
> const data_type* data() const
> {
> return impl_.data();
> }
>
>
> std::size_t size() const
> {
> return impl_.size();
> }
>
>
> void resize(std::size_t new_size)
> {
> impl_.resize(new_size);
> }
>
>
> std::size_t capacity() const
> {
> return impl_.capacity();
> }
>
>
> friend bool operator==(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return e1.impl_ == e2.impl_;
> }
>
>
> friend bool operator!=(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return !(e1.impl_ == e2.impl_);
> }
>
>
> friend bool operator<(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return e1.impl_ < e2.impl_;
> }
>
>
> friend bool operator>(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return e2.impl_ < e1.impl_;
> }
>
>
> friend bool operator<=(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return !(e2 < e1);
> }
>
>
> friend bool operator>=(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return !(e1 < e2);
> }
>
>private:
>
> boost::asio::generic::detail::endpoint impl_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 194 "/usr/include/boost/asio/generic/basic_endpoint.hpp" 2 3 4
># 50 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/generic/datagram_protocol.hpp" 1 3 4
># 26 "/usr/include/boost/asio/generic/datagram_protocol.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/generic/datagram_protocol.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace generic {
># 50 "/usr/include/boost/asio/generic/datagram_protocol.hpp" 3 4
>class datagram_protocol
>{
>public:
>
> datagram_protocol(int address_family, int socket_protocol)
> : family_(address_family),
> protocol_(socket_protocol)
> {
> }
>
>
>
>
>
> template <typename Protocol>
> datagram_protocol(const Protocol& source_protocol)
> : family_(source_protocol.family()),
> protocol_(source_protocol.protocol())
> {
> if (source_protocol.type() != type())
> {
> std::bad_cast ex;
> boost::asio::detail::throw_exception(ex);
> }
> }
>
>
> int type() const
> {
> return SOCK_DGRAM;
> }
>
>
> int protocol() const
> {
> return protocol_;
> }
>
>
> int family() const
> {
> return family_;
> }
>
>
> friend bool operator==(const datagram_protocol& p1,
> const datagram_protocol& p2)
> {
> return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
> }
>
>
> friend bool operator!=(const datagram_protocol& p1,
> const datagram_protocol& p2)
> {
> return !(p1 == p2);
> }
>
>
> typedef basic_endpoint<datagram_protocol> endpoint;
>
>
> typedef basic_datagram_socket<datagram_protocol> socket;
>
>private:
> int family_;
> int protocol_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 124 "/usr/include/boost/asio/generic/datagram_protocol.hpp" 2 3 4
># 51 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/generic/raw_protocol.hpp" 1 3 4
># 26 "/usr/include/boost/asio/generic/raw_protocol.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/generic/raw_protocol.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace generic {
># 50 "/usr/include/boost/asio/generic/raw_protocol.hpp" 3 4
>class raw_protocol
>{
>public:
>
> raw_protocol(int address_family, int socket_protocol)
> : family_(address_family),
> protocol_(socket_protocol)
> {
> }
>
>
>
>
>
> template <typename Protocol>
> raw_protocol(const Protocol& source_protocol)
> : family_(source_protocol.family()),
> protocol_(source_protocol.protocol())
> {
> if (source_protocol.type() != type())
> {
> std::bad_cast ex;
> boost::asio::detail::throw_exception(ex);
> }
> }
>
>
> int type() const
> {
> return SOCK_RAW;
> }
>
>
> int protocol() const
> {
> return protocol_;
> }
>
>
> int family() const
> {
> return family_;
> }
>
>
> friend bool operator==(const raw_protocol& p1, const raw_protocol& p2)
> {
> return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
> }
>
>
> friend bool operator!=(const raw_protocol& p1, const raw_protocol& p2)
> {
> return !(p1 == p2);
> }
>
>
> typedef basic_endpoint<raw_protocol> endpoint;
>
>
> typedef basic_raw_socket<raw_protocol> socket;
>
>private:
> int family_;
> int protocol_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 122 "/usr/include/boost/asio/generic/raw_protocol.hpp" 2 3 4
># 52 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/generic/seq_packet_protocol.hpp" 1 3 4
># 26 "/usr/include/boost/asio/generic/seq_packet_protocol.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/generic/seq_packet_protocol.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace generic {
># 48 "/usr/include/boost/asio/generic/seq_packet_protocol.hpp" 3 4
>class seq_packet_protocol
>{
>public:
>
> seq_packet_protocol(int address_family, int socket_protocol)
> : family_(address_family),
> protocol_(socket_protocol)
> {
> }
>
>
>
>
>
>
> template <typename Protocol>
> seq_packet_protocol(const Protocol& source_protocol)
> : family_(source_protocol.family()),
> protocol_(source_protocol.protocol())
> {
> if (source_protocol.type() != type())
> {
> std::bad_cast ex;
> boost::asio::detail::throw_exception(ex);
> }
> }
>
>
> int type() const
> {
> return SOCK_SEQPACKET;
> }
>
>
> int protocol() const
> {
> return protocol_;
> }
>
>
> int family() const
> {
> return family_;
> }
>
>
> friend bool operator==(const seq_packet_protocol& p1,
> const seq_packet_protocol& p2)
> {
> return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
> }
>
>
> friend bool operator!=(const seq_packet_protocol& p1,
> const seq_packet_protocol& p2)
> {
> return !(p1 == p2);
> }
>
>
> typedef basic_endpoint<seq_packet_protocol> endpoint;
>
>
> typedef basic_seq_packet_socket<seq_packet_protocol> socket;
>
>private:
> int family_;
> int protocol_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 123 "/usr/include/boost/asio/generic/seq_packet_protocol.hpp" 2 3 4
># 53 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/generic/stream_protocol.hpp" 1 3 4
># 27 "/usr/include/boost/asio/generic/stream_protocol.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/generic/stream_protocol.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace generic {
># 51 "/usr/include/boost/asio/generic/stream_protocol.hpp" 3 4
>class stream_protocol
>{
>public:
>
> stream_protocol(int address_family, int socket_protocol)
> : family_(address_family),
> protocol_(socket_protocol)
> {
> }
>
>
>
>
>
> template <typename Protocol>
> stream_protocol(const Protocol& source_protocol)
> : family_(source_protocol.family()),
> protocol_(source_protocol.protocol())
> {
> if (source_protocol.type() != type())
> {
> std::bad_cast ex;
> boost::asio::detail::throw_exception(ex);
> }
> }
>
>
> int type() const
> {
> return SOCK_STREAM;
> }
>
>
> int protocol() const
> {
> return protocol_;
> }
>
>
> int family() const
> {
> return family_;
> }
>
>
> friend bool operator==(const stream_protocol& p1, const stream_protocol& p2)
> {
> return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
> }
>
>
> friend bool operator!=(const stream_protocol& p1, const stream_protocol& p2)
> {
> return !(p1 == p2);
> }
>
>
> typedef basic_endpoint<stream_protocol> endpoint;
>
>
> typedef basic_stream_socket<stream_protocol> socket;
>
>
>
> typedef basic_socket_iostream<stream_protocol> iostream;
>
>
>private:
> int family_;
> int protocol_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 128 "/usr/include/boost/asio/generic/stream_protocol.hpp" 2 3 4
># 54 "/usr/include/boost/asio.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/ip/address.hpp" 1 3 4
># 21 "/usr/include/boost/asio/ip/address.hpp" 3 4
># 1 "/usr/include/boost/asio/ip/address_v4.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/address_v4.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/winsock_init.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ip/address_v4.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 30 "/usr/include/boost/asio/ip/address_v4.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 44 "/usr/include/boost/asio/ip/address_v4.hpp" 3 4
>class address_v4
>{
>public:
># 55 "/usr/include/boost/asio/ip/address_v4.hpp" 3 4
> typedef boost::asio::detail::array<unsigned char, 4> bytes_type;
>
>
>
> address_v4()
> {
> addr_.s_addr = 0;
> }
>
>
> inline explicit address_v4(const bytes_type& bytes);
>
>
> inline explicit address_v4(unsigned long addr);
>
>
> address_v4(const address_v4& other)
> : addr_(other.addr_)
> {
> }
>
>
>
> address_v4(address_v4&& other)
> : addr_(other.addr_)
> {
> }
>
>
>
> address_v4& operator=(const address_v4& other)
> {
> addr_ = other.addr_;
> return *this;
> }
>
>
>
> address_v4& operator=(address_v4&& other)
> {
> addr_ = other.addr_;
> return *this;
> }
>
>
>
> inline bytes_type to_bytes() const;
>
>
> inline unsigned long to_ulong() const;
>
>
> inline std::string to_string() const;
>
>
> inline std::string to_string(boost::system::error_code& ec) const;
>
>
> inline static address_v4 from_string(const char* str);
>
>
> inline static address_v4 from_string(
> const char* str, boost::system::error_code& ec);
>
>
> inline static address_v4 from_string(const std::string& str);
>
>
> inline static address_v4 from_string(
> const std::string& str, boost::system::error_code& ec);
>
>
> inline bool is_loopback() const;
>
>
> inline bool is_unspecified() const;
>
>
> inline bool is_class_a() const;
>
>
> inline bool is_class_b() const;
>
>
> inline bool is_class_c() const;
>
>
> inline bool is_multicast() const;
>
>
> friend bool operator==(const address_v4& a1, const address_v4& a2)
> {
> return a1.addr_.s_addr == a2.addr_.s_addr;
> }
>
>
> friend bool operator!=(const address_v4& a1, const address_v4& a2)
> {
> return a1.addr_.s_addr != a2.addr_.s_addr;
> }
>
>
> friend bool operator<(const address_v4& a1, const address_v4& a2)
> {
> return a1.to_ulong() < a2.to_ulong();
> }
>
>
> friend bool operator>(const address_v4& a1, const address_v4& a2)
> {
> return a1.to_ulong() > a2.to_ulong();
> }
>
>
> friend bool operator<=(const address_v4& a1, const address_v4& a2)
> {
> return a1.to_ulong() <= a2.to_ulong();
> }
>
>
> friend bool operator>=(const address_v4& a1, const address_v4& a2)
> {
> return a1.to_ulong() >= a2.to_ulong();
> }
>
>
> static address_v4 any()
> {
> return address_v4();
> }
>
>
> static address_v4 loopback()
> {
> return address_v4(0x7F000001);
> }
>
>
> static address_v4 broadcast()
> {
> return address_v4(0xFFFFFFFF);
> }
>
>
>
> inline static address_v4 broadcast(
> const address_v4& addr, const address_v4& mask);
>
>
>
> inline static address_v4 netmask(const address_v4& addr);
>
>private:
>
> boost::asio::detail::in4_addr_type addr_;
>};
># 226 "/usr/include/boost/asio/ip/address_v4.hpp" 3 4
>template <typename Elem, typename Traits>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os, const address_v4& addr);
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 237 "/usr/include/boost/asio/ip/address_v4.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/impl/address_v4.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/impl/address_v4.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ip/impl/address_v4.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>template <typename Elem, typename Traits>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os, const address_v4& addr)
>{
> boost::system::error_code ec;
> std::string s = addr.to_string(ec);
> if (ec)
> {
> if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
> boost::asio::detail::throw_error(ec);
> else
> os.setstate(std::basic_ostream<Elem, Traits>::failbit);
> }
> else
> for (std::string::iterator i = s.begin(); i != s.end(); ++i)
> os << os.widen(*i);
> return os;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 52 "/usr/include/boost/asio/ip/impl/address_v4.hpp" 2 3 4
># 239 "/usr/include/boost/asio/ip/address_v4.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/impl/address_v4.ipp" 1 3 4
># 19 "/usr/include/boost/asio/ip/impl/address_v4.ipp" 3 4
># 1 "/usr/include/c++/4.8.2/climits" 1 3 4
># 39 "/usr/include/c++/4.8.2/climits" 3 4
> 
># 40 "/usr/include/c++/4.8.2/climits" 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/climits" 2 3
># 20 "/usr/include/boost/asio/ip/impl/address_v4.ipp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/ip/address_v4.hpp" 1 3 4
># 26 "/usr/include/boost/asio/ip/impl/address_v4.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/ip/impl/address_v4.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>address_v4::address_v4(const address_v4::bytes_type& bytes)
>{
># 44 "/usr/include/boost/asio/ip/impl/address_v4.ipp" 3 4
> using namespace std;
> memcpy(&addr_.s_addr, bytes.data(), 4);
>}
>
>address_v4::address_v4(unsigned long addr)
>{
>
> if (addr > 0xFFFFFFFF)
> {
> std::out_of_range ex("address_v4 from unsigned long");
> boost::asio::detail::throw_exception(ex);
> }
>
>
> addr_.s_addr = boost::asio::detail::socket_ops::host_to_network_long(
> static_cast<boost::asio::detail::u_long_type>(addr));
>}
>
>address_v4::bytes_type address_v4::to_bytes() const
>{
> using namespace std;
> bytes_type bytes;
>
> memcpy(bytes.data(), &addr_.s_addr, 4);
>
>
>
> return bytes;
>}
>
>unsigned long address_v4::to_ulong() const
>{
> return boost::asio::detail::socket_ops::network_to_host_long(addr_.s_addr);
>}
>
>std::string address_v4::to_string() const
>{
> boost::system::error_code ec;
> std::string addr = to_string(ec);
> boost::asio::detail::throw_error(ec);
> return addr;
>}
>
>std::string address_v4::to_string(boost::system::error_code& ec) const
>{
> char addr_str[boost::asio::detail::max_addr_v4_str_len];
> const char* addr =
> boost::asio::detail::socket_ops::inet_ntop(2, &addr_, addr_str,
> boost::asio::detail::max_addr_v4_str_len, 0, ec);
> if (addr == 0)
> return std::string();
> return addr;
>}
>
>address_v4 address_v4::from_string(const char* str)
>{
> boost::system::error_code ec;
> address_v4 addr = from_string(str, ec);
> boost::asio::detail::throw_error(ec);
> return addr;
>}
>
>address_v4 address_v4::from_string(
> const char* str, boost::system::error_code& ec)
>{
> address_v4 tmp;
> if (boost::asio::detail::socket_ops::inet_pton(
> 2, str, &tmp.addr_, 0, ec) <= 0)
> return address_v4();
> return tmp;
>}
>
>address_v4 address_v4::from_string(const std::string& str)
>{
> return from_string(str.c_str());
>}
>
>address_v4 address_v4::from_string(
> const std::string& str, boost::system::error_code& ec)
>{
> return from_string(str.c_str(), ec);
>}
>
>bool address_v4::is_loopback() const
>{
> return (to_ulong() & 0xFF000000) == 0x7F000000;
>}
>
>bool address_v4::is_unspecified() const
>{
> return to_ulong() == 0;
>}
>
>bool address_v4::is_class_a() const
>{
> return (to_ulong() & 0x80000000) == 0;
>}
>
>bool address_v4::is_class_b() const
>{
> return (to_ulong() & 0xC0000000) == 0x80000000;
>}
>
>bool address_v4::is_class_c() const
>{
> return (to_ulong() & 0xE0000000) == 0xC0000000;
>}
>
>bool address_v4::is_multicast() const
>{
> return (to_ulong() & 0xF0000000) == 0xE0000000;
>}
>
>address_v4 address_v4::broadcast(const address_v4& addr, const address_v4& mask)
>{
> return address_v4(addr.to_ulong() | (mask.to_ulong() ^ 0xFFFFFFFF));
>}
>
>address_v4 address_v4::netmask(const address_v4& addr)
>{
> if (addr.is_class_a())
> return address_v4(0xFF000000);
> if (addr.is_class_b())
> return address_v4(0xFFFF0000);
> if (addr.is_class_c())
> return address_v4(0xFFFFFF00);
> return address_v4(0xFFFFFFFF);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 178 "/usr/include/boost/asio/ip/impl/address_v4.ipp" 2 3 4
># 241 "/usr/include/boost/asio/ip/address_v4.hpp" 2 3 4
># 22 "/usr/include/boost/asio/ip/address.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/address_v6.hpp" 1 3 4
># 30 "/usr/include/boost/asio/ip/address_v6.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 31 "/usr/include/boost/asio/ip/address_v6.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 45 "/usr/include/boost/asio/ip/address_v6.hpp" 3 4
>class address_v6
>{
>public:
># 56 "/usr/include/boost/asio/ip/address_v6.hpp" 3 4
> typedef boost::asio::detail::array<unsigned char, 16> bytes_type;
>
>
>
> inline address_v6();
>
>
> inline explicit address_v6(const bytes_type& bytes,
> unsigned long scope_id = 0);
>
>
> inline address_v6(const address_v6& other);
>
>
>
> inline address_v6(address_v6&& other);
>
>
>
> inline address_v6& operator=(const address_v6& other);
>
>
>
> inline address_v6& operator=(address_v6&& other);
>
>
>
>
>
>
> unsigned long scope_id() const
> {
> return scope_id_;
> }
>
>
>
>
>
> void scope_id(unsigned long id)
> {
> scope_id_ = id;
> }
>
>
> inline bytes_type to_bytes() const;
>
>
> inline std::string to_string() const;
>
>
> inline std::string to_string(boost::system::error_code& ec) const;
>
>
> inline static address_v6 from_string(const char* str);
>
>
> inline static address_v6 from_string(
> const char* str, boost::system::error_code& ec);
>
>
> inline static address_v6 from_string(const std::string& str);
>
>
> inline static address_v6 from_string(
> const std::string& str, boost::system::error_code& ec);
>
>
> inline address_v4 to_v4() const;
>
>
> inline bool is_loopback() const;
>
>
> inline bool is_unspecified() const;
>
>
> inline bool is_link_local() const;
>
>
> inline bool is_site_local() const;
>
>
> inline bool is_v4_mapped() const;
>
>
> inline bool is_v4_compatible() const;
>
>
> inline bool is_multicast() const;
>
>
> inline bool is_multicast_global() const;
>
>
> inline bool is_multicast_link_local() const;
>
>
> inline bool is_multicast_node_local() const;
>
>
> inline bool is_multicast_org_local() const;
>
>
> inline bool is_multicast_site_local() const;
>
>
> inline friend bool operator==(
> const address_v6& a1, const address_v6& a2);
>
>
> friend bool operator!=(const address_v6& a1, const address_v6& a2)
> {
> return !(a1 == a2);
> }
>
>
> inline friend bool operator<(
> const address_v6& a1, const address_v6& a2);
>
>
> friend bool operator>(const address_v6& a1, const address_v6& a2)
> {
> return a2 < a1;
> }
>
>
> friend bool operator<=(const address_v6& a1, const address_v6& a2)
> {
> return !(a2 < a1);
> }
>
>
> friend bool operator>=(const address_v6& a1, const address_v6& a2)
> {
> return !(a1 < a2);
> }
>
>
> static address_v6 any()
> {
> return address_v6();
> }
>
>
> inline static address_v6 loopback();
>
>
> inline static address_v6 v4_mapped(const address_v4& addr);
>
>
> inline static address_v6 v4_compatible(const address_v4& addr);
>
>private:
>
> boost::asio::detail::in6_addr_type addr_;
>
>
> unsigned long scope_id_;
>};
># 231 "/usr/include/boost/asio/ip/address_v6.hpp" 3 4
>template <typename Elem, typename Traits>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os, const address_v6& addr);
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 242 "/usr/include/boost/asio/ip/address_v6.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/impl/address_v6.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/impl/address_v6.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ip/impl/address_v6.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>template <typename Elem, typename Traits>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os, const address_v6& addr)
>{
> boost::system::error_code ec;
> std::string s = addr.to_string(ec);
> if (ec)
> {
> if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
> boost::asio::detail::throw_error(ec);
> else
> os.setstate(std::basic_ostream<Elem, Traits>::failbit);
> }
> else
> for (std::string::iterator i = s.begin(); i != s.end(); ++i)
> os << os.widen(*i);
> return os;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 52 "/usr/include/boost/asio/ip/impl/address_v6.hpp" 2 3 4
># 244 "/usr/include/boost/asio/ip/address_v6.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/impl/address_v6.ipp" 1 3 4
># 19 "/usr/include/boost/asio/ip/impl/address_v6.ipp" 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 20 "/usr/include/boost/asio/ip/impl/address_v6.ipp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/ip/address_v6.hpp" 1 3 4
># 27 "/usr/include/boost/asio/ip/impl/address_v6.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 29 "/usr/include/boost/asio/ip/impl/address_v6.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>address_v6::address_v6()
> : addr_(),
> scope_id_(0)
>{
>}
>
>address_v6::address_v6(const address_v6::bytes_type& bytes,
> unsigned long scope)
> : scope_id_(scope)
>{
># 55 "/usr/include/boost/asio/ip/impl/address_v6.ipp" 3 4
> using namespace std;
> memcpy(addr_.__in6_u.__u6_addr8, bytes.data(), 16);
>}
>
>address_v6::address_v6(const address_v6& other)
> : addr_(other.addr_),
> scope_id_(other.scope_id_)
>{
>}
>
>
>address_v6::address_v6(address_v6&& other)
> : addr_(other.addr_),
> scope_id_(other.scope_id_)
>{
>}
>
>
>address_v6& address_v6::operator=(const address_v6& other)
>{
> addr_ = other.addr_;
> scope_id_ = other.scope_id_;
> return *this;
>}
>
>
>address_v6& address_v6::operator=(address_v6&& other)
>{
> addr_ = other.addr_;
> scope_id_ = other.scope_id_;
> return *this;
>}
>
>
>address_v6::bytes_type address_v6::to_bytes() const
>{
> using namespace std;
> bytes_type bytes;
>
> memcpy(bytes.data(), addr_.__in6_u.__u6_addr8, 16);
>
>
>
> return bytes;
>}
>
>std::string address_v6::to_string() const
>{
> boost::system::error_code ec;
> std::string addr = to_string(ec);
> boost::asio::detail::throw_error(ec);
> return addr;
>}
>
>std::string address_v6::to_string(boost::system::error_code& ec) const
>{
> char addr_str[boost::asio::detail::max_addr_v6_str_len];
> const char* addr =
> boost::asio::detail::socket_ops::inet_ntop(10, &addr_, addr_str,
> boost::asio::detail::max_addr_v6_str_len, scope_id_, ec);
> if (addr == 0)
> return std::string();
> return addr;
>}
>
>address_v6 address_v6::from_string(const char* str)
>{
> boost::system::error_code ec;
> address_v6 addr = from_string(str, ec);
> boost::asio::detail::throw_error(ec);
> return addr;
>}
>
>address_v6 address_v6::from_string(
> const char* str, boost::system::error_code& ec)
>{
> address_v6 tmp;
> if (boost::asio::detail::socket_ops::inet_pton(
> 10, str, &tmp.addr_, &tmp.scope_id_, ec) <= 0)
> return address_v6();
> return tmp;
>}
>
>address_v6 address_v6::from_string(const std::string& str)
>{
> return from_string(str.c_str());
>}
>
>address_v6 address_v6::from_string(
> const std::string& str, boost::system::error_code& ec)
>{
> return from_string(str.c_str(), ec);
>}
>
>address_v4 address_v6::to_v4() const
>{
> if (!is_v4_mapped() && !is_v4_compatible())
> {
> std::bad_cast ex;
> boost::asio::detail::throw_exception(ex);
> }
>
> address_v4::bytes_type v4_bytes = { { addr_.__in6_u.__u6_addr8[12],
> addr_.__in6_u.__u6_addr8[13], addr_.__in6_u.__u6_addr8[14], addr_.__in6_u.__u6_addr8[15] } };
> return address_v4(v4_bytes);
>}
>
>bool address_v6::is_loopback() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
> && (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
> && (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
> && (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
> && (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
> && (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
> && (addr_.__in6_u.__u6_addr8[12] == 0) && (addr_.__in6_u.__u6_addr8[13] == 0)
> && (addr_.__in6_u.__u6_addr8[14] == 0) && (addr_.__in6_u.__u6_addr8[15] == 1));
>}
>
>bool address_v6::is_unspecified() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
> && (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
> && (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
> && (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
> && (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
> && (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
> && (addr_.__in6_u.__u6_addr8[12] == 0) && (addr_.__in6_u.__u6_addr8[13] == 0)
> && (addr_.__in6_u.__u6_addr8[14] == 0) && (addr_.__in6_u.__u6_addr8[15] == 0));
>}
>
>bool address_v6::is_link_local() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0xfe) && ((addr_.__in6_u.__u6_addr8[1] & 0xc0) == 0x80));
>}
>
>bool address_v6::is_site_local() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0xfe) && ((addr_.__in6_u.__u6_addr8[1] & 0xc0) == 0xc0));
>}
>
>bool address_v6::is_v4_mapped() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
> && (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
> && (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
> && (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
> && (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
> && (addr_.__in6_u.__u6_addr8[10] == 0xff) && (addr_.__in6_u.__u6_addr8[11] == 0xff));
>}
>
>bool address_v6::is_v4_compatible() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
> && (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
> && (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
> && (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
> && (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
> && (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
> && !((addr_.__in6_u.__u6_addr8[12] == 0)
> && (addr_.__in6_u.__u6_addr8[13] == 0)
> && (addr_.__in6_u.__u6_addr8[14] == 0)
> && ((addr_.__in6_u.__u6_addr8[15] == 0) || (addr_.__in6_u.__u6_addr8[15] == 1))));
>}
>
>bool address_v6::is_multicast() const
>{
> return (addr_.__in6_u.__u6_addr8[0] == 0xff);
>}
>
>bool address_v6::is_multicast_global() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x0e));
>}
>
>bool address_v6::is_multicast_link_local() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x02));
>}
>
>bool address_v6::is_multicast_node_local() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x01));
>}
>
>bool address_v6::is_multicast_org_local() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x08));
>}
>
>bool address_v6::is_multicast_site_local() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x05));
>}
>
>bool operator==(const address_v6& a1, const address_v6& a2)
>{
> using namespace std;
> return memcmp(&a1.addr_, &a2.addr_,
> sizeof(boost::asio::detail::in6_addr_type)) == 0
> && a1.scope_id_ == a2.scope_id_;
>}
>
>bool operator<(const address_v6& a1, const address_v6& a2)
>{
> using namespace std;
> int memcmp_result = memcmp(&a1.addr_, &a2.addr_,
> sizeof(boost::asio::detail::in6_addr_type));
> if (memcmp_result < 0)
> return true;
> if (memcmp_result > 0)
> return false;
> return a1.scope_id_ < a2.scope_id_;
>}
>
>address_v6 address_v6::loopback()
>{
> address_v6 tmp;
> tmp.addr_.__in6_u.__u6_addr8[15] = 1;
> return tmp;
>}
>
>address_v6 address_v6::v4_mapped(const address_v4& addr)
>{
> address_v4::bytes_type v4_bytes = addr.to_bytes();
> bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF,
> v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
> return address_v6(v6_bytes);
>}
>
>address_v6 address_v6::v4_compatible(const address_v4& addr)
>{
> address_v4::bytes_type v4_bytes = addr.to_bytes();
> bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
> v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
> return address_v6(v6_bytes);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 298 "/usr/include/boost/asio/ip/impl/address_v6.ipp" 2 3 4
># 246 "/usr/include/boost/asio/ip/address_v6.hpp" 2 3 4
># 23 "/usr/include/boost/asio/ip/address.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 29 "/usr/include/boost/asio/ip/address.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 43 "/usr/include/boost/asio/ip/address.hpp" 3 4
>class address
>{
>public:
>
> inline address();
>
>
> inline address(const boost::asio::ip::address_v4& ipv4_address);
>
>
> inline address(const boost::asio::ip::address_v6& ipv6_address);
>
>
> inline address(const address& other);
>
>
>
> inline address(address&& other);
>
>
>
> inline address& operator=(const address& other);
>
>
>
> inline address& operator=(address&& other);
>
>
>
> inline address& operator=(
> const boost::asio::ip::address_v4& ipv4_address);
>
>
> inline address& operator=(
> const boost::asio::ip::address_v6& ipv6_address);
>
>
> bool is_v4() const
> {
> return type_ == ipv4;
> }
>
>
> bool is_v6() const
> {
> return type_ == ipv6;
> }
>
>
> inline boost::asio::ip::address_v4 to_v4() const;
>
>
> inline boost::asio::ip::address_v6 to_v6() const;
>
>
> inline std::string to_string() const;
>
>
> inline std::string to_string(boost::system::error_code& ec) const;
>
>
>
> inline static address from_string(const char* str);
>
>
>
> inline static address from_string(
> const char* str, boost::system::error_code& ec);
>
>
>
> inline static address from_string(const std::string& str);
>
>
>
> inline static address from_string(
> const std::string& str, boost::system::error_code& ec);
>
>
> inline bool is_loopback() const;
>
>
> inline bool is_unspecified() const;
>
>
> inline bool is_multicast() const;
>
>
> inline friend bool operator==(const address& a1, const address& a2);
>
>
> friend bool operator!=(const address& a1, const address& a2)
> {
> return !(a1 == a2);
> }
>
>
> inline friend bool operator<(const address& a1, const address& a2);
>
>
> friend bool operator>(const address& a1, const address& a2)
> {
> return a2 < a1;
> }
>
>
> friend bool operator<=(const address& a1, const address& a2)
> {
> return !(a2 < a1);
> }
>
>
> friend bool operator>=(const address& a1, const address& a2)
> {
> return !(a1 < a2);
> }
>
>private:
>
> enum { ipv4, ipv6 } type_;
>
>
> boost::asio::ip::address_v4 ipv4_address_;
>
>
> boost::asio::ip::address_v6 ipv6_address_;
>};
># 185 "/usr/include/boost/asio/ip/address.hpp" 3 4
>template <typename Elem, typename Traits>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os, const address& addr);
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 196 "/usr/include/boost/asio/ip/address.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/impl/address.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/impl/address.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ip/impl/address.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>template <typename Elem, typename Traits>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os, const address& addr)
>{
> boost::system::error_code ec;
> std::string s = addr.to_string(ec);
> if (ec)
> {
> if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
> boost::asio::detail::throw_error(ec);
> else
> os.setstate(std::basic_ostream<Elem, Traits>::failbit);
> }
> else
> for (std::string::iterator i = s.begin(); i != s.end(); ++i)
> os << os.widen(*i);
> return os;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 52 "/usr/include/boost/asio/ip/impl/address.hpp" 2 3 4
># 198 "/usr/include/boost/asio/ip/address.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/impl/address.ipp" 1 3 4
># 23 "/usr/include/boost/asio/ip/impl/address.ipp" 3 4
># 1 "/usr/include/boost/asio/ip/address.hpp" 1 3 4
># 24 "/usr/include/boost/asio/ip/impl/address.ipp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/ip/impl/address.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>address::address()
> : type_(ipv4),
> ipv4_address_(),
> ipv6_address_()
>{
>}
>
>address::address(const boost::asio::ip::address_v4& ipv4_address)
> : type_(ipv4),
> ipv4_address_(ipv4_address),
> ipv6_address_()
>{
>}
>
>address::address(const boost::asio::ip::address_v6& ipv6_address)
> : type_(ipv6),
> ipv4_address_(),
> ipv6_address_(ipv6_address)
>{
>}
>
>address::address(const address& other)
> : type_(other.type_),
> ipv4_address_(other.ipv4_address_),
> ipv6_address_(other.ipv6_address_)
>{
>}
>
>
>address::address(address&& other)
> : type_(other.type_),
> ipv4_address_(other.ipv4_address_),
> ipv6_address_(other.ipv6_address_)
>{
>}
>
>
>address& address::operator=(const address& other)
>{
> type_ = other.type_;
> ipv4_address_ = other.ipv4_address_;
> ipv6_address_ = other.ipv6_address_;
> return *this;
>}
>
>
>address& address::operator=(address&& other)
>{
> type_ = other.type_;
> ipv4_address_ = other.ipv4_address_;
> ipv6_address_ = other.ipv6_address_;
> return *this;
>}
>
>
>address& address::operator=(const boost::asio::ip::address_v4& ipv4_address)
>{
> type_ = ipv4;
> ipv4_address_ = ipv4_address;
> ipv6_address_ = boost::asio::ip::address_v6();
> return *this;
>}
>
>address& address::operator=(const boost::asio::ip::address_v6& ipv6_address)
>{
> type_ = ipv6;
> ipv4_address_ = boost::asio::ip::address_v4();
> ipv6_address_ = ipv6_address;
> return *this;
>}
>
>boost::asio::ip::address_v4 address::to_v4() const
>{
> if (type_ != ipv4)
> {
> std::bad_cast ex;
> boost::asio::detail::throw_exception(ex);
> }
> return ipv4_address_;
>}
>
>boost::asio::ip::address_v6 address::to_v6() const
>{
> if (type_ != ipv6)
> {
> std::bad_cast ex;
> boost::asio::detail::throw_exception(ex);
> }
> return ipv6_address_;
>}
>
>std::string address::to_string() const
>{
> if (type_ == ipv6)
> return ipv6_address_.to_string();
> return ipv4_address_.to_string();
>}
>
>std::string address::to_string(boost::system::error_code& ec) const
>{
> if (type_ == ipv6)
> return ipv6_address_.to_string(ec);
> return ipv4_address_.to_string(ec);
>}
>
>address address::from_string(const char* str)
>{
> boost::system::error_code ec;
> address addr = from_string(str, ec);
> boost::asio::detail::throw_error(ec);
> return addr;
>}
>
>address address::from_string(const char* str, boost::system::error_code& ec)
>{
> boost::asio::ip::address_v6 ipv6_address =
> boost::asio::ip::address_v6::from_string(str, ec);
> if (!ec)
> {
> address tmp;
> tmp.type_ = ipv6;
> tmp.ipv6_address_ = ipv6_address;
> return tmp;
> }
>
> boost::asio::ip::address_v4 ipv4_address =
> boost::asio::ip::address_v4::from_string(str, ec);
> if (!ec)
> {
> address tmp;
> tmp.type_ = ipv4;
> tmp.ipv4_address_ = ipv4_address;
> return tmp;
> }
>
> return address();
>}
>
>address address::from_string(const std::string& str)
>{
> return from_string(str.c_str());
>}
>
>address address::from_string(const std::string& str,
> boost::system::error_code& ec)
>{
> return from_string(str.c_str(), ec);
>}
>
>bool address::is_loopback() const
>{
> return (type_ == ipv4)
> ? ipv4_address_.is_loopback()
> : ipv6_address_.is_loopback();
>}
>
>bool address::is_unspecified() const
>{
> return (type_ == ipv4)
> ? ipv4_address_.is_unspecified()
> : ipv6_address_.is_unspecified();
>}
>
>bool address::is_multicast() const
>{
> return (type_ == ipv4)
> ? ipv4_address_.is_multicast()
> : ipv6_address_.is_multicast();
>}
>
>bool operator==(const address& a1, const address& a2)
>{
> if (a1.type_ != a2.type_)
> return false;
> if (a1.type_ == address::ipv6)
> return a1.ipv6_address_ == a2.ipv6_address_;
> return a1.ipv4_address_ == a2.ipv4_address_;
>}
>
>bool operator<(const address& a1, const address& a2)
>{
> if (a1.type_ < a2.type_)
> return true;
> if (a1.type_ > a2.type_)
> return false;
> if (a1.type_ == address::ipv6)
> return a1.ipv6_address_ < a2.ipv6_address_;
> return a1.ipv4_address_ < a2.ipv4_address_;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 227 "/usr/include/boost/asio/ip/impl/address.ipp" 2 3 4
># 200 "/usr/include/boost/asio/ip/address.hpp" 2 3 4
># 60 "/usr/include/boost/asio.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 1 3 4
># 20 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 3 4
># 1 "/usr/include/boost/asio/ip/detail/endpoint.hpp" 1 3 4
># 25 "/usr/include/boost/asio/ip/detail/endpoint.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/ip/detail/endpoint.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>namespace detail {
>
>
>class endpoint
>{
>public:
>
> inline endpoint();
>
>
> inline endpoint(int family, unsigned short port_num);
>
>
> inline endpoint(const boost::asio::ip::address& addr,
> unsigned short port_num);
>
>
> endpoint(const endpoint& other)
> : data_(other.data_)
> {
> }
>
>
> endpoint& operator=(const endpoint& other)
> {
> data_ = other.data_;
> return *this;
> }
>
>
> boost::asio::detail::socket_addr_type* data()
> {
> return &data_.base;
> }
>
>
> const boost::asio::detail::socket_addr_type* data() const
> {
> return &data_.base;
> }
>
>
> std::size_t size() const
> {
> if (is_v4())
> return sizeof(boost::asio::detail::sockaddr_in4_type);
> else
> return sizeof(boost::asio::detail::sockaddr_in6_type);
> }
>
>
> inline void resize(std::size_t new_size);
>
>
> std::size_t capacity() const
> {
> return sizeof(data_);
> }
>
>
> inline unsigned short port() const;
>
>
> inline void port(unsigned short port_num);
>
>
> inline boost::asio::ip::address address() const;
>
>
> inline void address(const boost::asio::ip::address& addr);
>
>
> inline friend bool operator==(
> const endpoint& e1, const endpoint& e2);
>
>
> inline friend bool operator<(
> const endpoint& e1, const endpoint& e2);
>
>
> bool is_v4() const
> {
> return data_.base.sa_family == 2;
> }
>
>
>
> inline std::string to_string(boost::system::error_code& ec) const;
>
>
>private:
>
> union data_union
> {
> boost::asio::detail::socket_addr_type base;
> boost::asio::detail::sockaddr_in4_type v4;
> boost::asio::detail::sockaddr_in6_type v6;
> } data_;
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 136 "/usr/include/boost/asio/ip/detail/endpoint.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/ip/detail/impl/endpoint.ipp" 1 3 4
># 19 "/usr/include/boost/asio/ip/detail/impl/endpoint.ipp" 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 20 "/usr/include/boost/asio/ip/detail/impl/endpoint.ipp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/ip/detail/endpoint.hpp" 1 3 4
># 27 "/usr/include/boost/asio/ip/detail/impl/endpoint.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 29 "/usr/include/boost/asio/ip/detail/impl/endpoint.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>namespace detail {
>
>endpoint::endpoint()
> : data_()
>{
> data_.v4.sin_family = 2;
> data_.v4.sin_port = 0;
> data_.v4.sin_addr.s_addr = ((in_addr_t) 0x00000000);
>}
>
>endpoint::endpoint(int family, unsigned short port_num)
> : data_()
>{
> using namespace std;
> if (family == 2)
> {
> data_.v4.sin_family = 2;
> data_.v4.sin_port =
> boost::asio::detail::socket_ops::host_to_network_short(port_num);
> data_.v4.sin_addr.s_addr = ((in_addr_t) 0x00000000);
> }
> else
> {
> data_.v6.sin6_family = 10;
> data_.v6.sin6_port =
> boost::asio::detail::socket_ops::host_to_network_short(port_num);
> data_.v6.sin6_flowinfo = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[0] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[1] = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[2] = 0, data_.v6.sin6_addr.__in6_u.__u6_addr8[3] = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[4] = 0, data_.v6.sin6_addr.__in6_u.__u6_addr8[5] = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[6] = 0, data_.v6.sin6_addr.__in6_u.__u6_addr8[7] = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[8] = 0, data_.v6.sin6_addr.__in6_u.__u6_addr8[9] = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[10] = 0, data_.v6.sin6_addr.__in6_u.__u6_addr8[11] = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[12] = 0, data_.v6.sin6_addr.__in6_u.__u6_addr8[13] = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[14] = 0, data_.v6.sin6_addr.__in6_u.__u6_addr8[15] = 0;
> data_.v6.sin6_scope_id = 0;
> }
>}
>
>endpoint::endpoint(const boost::asio::ip::address& addr,
> unsigned short port_num)
> : data_()
>{
> using namespace std;
> if (addr.is_v4())
> {
> data_.v4.sin_family = 2;
> data_.v4.sin_port =
> boost::asio::detail::socket_ops::host_to_network_short(port_num);
> data_.v4.sin_addr.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> static_cast<boost::asio::detail::u_long_type>(
> addr.to_v4().to_ulong()));
> }
> else
> {
> data_.v6.sin6_family = 10;
> data_.v6.sin6_port =
> boost::asio::detail::socket_ops::host_to_network_short(port_num);
> data_.v6.sin6_flowinfo = 0;
> boost::asio::ip::address_v6 v6_addr = addr.to_v6();
> boost::asio::ip::address_v6::bytes_type bytes = v6_addr.to_bytes();
> memcpy(data_.v6.sin6_addr.__in6_u.__u6_addr8, bytes.data(), 16);
> data_.v6.sin6_scope_id =
> static_cast<boost::asio::detail::u_long_type>(
> v6_addr.scope_id());
> }
>}
>
>void endpoint::resize(std::size_t new_size)
>{
> if (new_size > sizeof(boost::asio::detail::sockaddr_storage_type))
> {
> boost::system::error_code ec(boost::asio::error::invalid_argument);
> boost::asio::detail::throw_error(ec);
> }
>}
>
>unsigned short endpoint::port() const
>{
> if (is_v4())
> {
> return boost::asio::detail::socket_ops::network_to_host_short(
> data_.v4.sin_port);
> }
> else
> {
> return boost::asio::detail::socket_ops::network_to_host_short(
> data_.v6.sin6_port);
> }
>}
>
>void endpoint::port(unsigned short port_num)
>{
> if (is_v4())
> {
> data_.v4.sin_port
> = boost::asio::detail::socket_ops::host_to_network_short(port_num);
> }
> else
> {
> data_.v6.sin6_port
> = boost::asio::detail::socket_ops::host_to_network_short(port_num);
> }
>}
>
>boost::asio::ip::address endpoint::address() const
>{
> using namespace std;
> if (is_v4())
> {
> return boost::asio::ip::address_v4(
> boost::asio::detail::socket_ops::network_to_host_long(
> data_.v4.sin_addr.s_addr));
> }
> else
> {
> boost::asio::ip::address_v6::bytes_type bytes;
>
> memcpy(bytes.data(), data_.v6.sin6_addr.__in6_u.__u6_addr8, 16);
>
>
>
> return boost::asio::ip::address_v6(bytes, data_.v6.sin6_scope_id);
> }
>}
>
>void endpoint::address(const boost::asio::ip::address& addr)
>{
> endpoint tmp_endpoint(addr, port());
> data_ = tmp_endpoint.data_;
>}
>
>bool operator==(const endpoint& e1, const endpoint& e2)
>{
> return e1.address() == e2.address() && e1.port() == e2.port();
>}
>
>bool operator<(const endpoint& e1, const endpoint& e2)
>{
> if (e1.address() < e2.address())
> return true;
> if (e1.address() != e2.address())
> return false;
> return e1.port() < e2.port();
>}
>
>
>std::string endpoint::to_string(boost::system::error_code& ec) const
>{
> std::string a = address().to_string(ec);
> if (ec)
> return std::string();
>
> std::ostringstream tmp_os;
> tmp_os.imbue(std::locale::classic());
> if (is_v4())
> tmp_os << a;
> else
> tmp_os << '[' << a << ']';
> tmp_os << ':' << port();
>
> return tmp_os.str();
>}
>
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 205 "/usr/include/boost/asio/ip/detail/impl/endpoint.ipp" 2 3 4
># 139 "/usr/include/boost/asio/ip/detail/endpoint.hpp" 2 3 4
># 21 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 44 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 3 4
>template <typename InternetProtocol>
>class basic_endpoint
>{
>public:
>
> typedef InternetProtocol protocol_type;
>
>
>
>
>
>
> typedef boost::asio::detail::socket_addr_type data_type;
>
>
>
> basic_endpoint()
> : impl_()
> {
> }
># 81 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 3 4
> basic_endpoint(const InternetProtocol& internet_protocol,
> unsigned short port_num)
> : impl_(internet_protocol.family(), port_num)
> {
> }
>
>
>
>
> basic_endpoint(const boost::asio::ip::address& addr, unsigned short port_num)
> : impl_(addr, port_num)
> {
> }
>
>
> basic_endpoint(const basic_endpoint& other)
> : impl_(other.impl_)
> {
> }
>
>
>
> basic_endpoint(basic_endpoint&& other)
> : impl_(other.impl_)
> {
> }
>
>
>
> basic_endpoint& operator=(const basic_endpoint& other)
> {
> impl_ = other.impl_;
> return *this;
> }
>
>
>
> basic_endpoint& operator=(basic_endpoint&& other)
> {
> impl_ = other.impl_;
> return *this;
> }
>
>
>
> protocol_type protocol() const
> {
> if (impl_.is_v4())
> return InternetProtocol::v4();
> return InternetProtocol::v6();
> }
>
>
> data_type* data()
> {
> return impl_.data();
> }
>
>
> const data_type* data() const
> {
> return impl_.data();
> }
>
>
> std::size_t size() const
> {
> return impl_.size();
> }
>
>
> void resize(std::size_t new_size)
> {
> impl_.resize(new_size);
> }
>
>
> std::size_t capacity() const
> {
> return impl_.capacity();
> }
>
>
>
> unsigned short port() const
> {
> return impl_.port();
> }
>
>
>
> void port(unsigned short port_num)
> {
> impl_.port(port_num);
> }
>
>
> boost::asio::ip::address address() const
> {
> return impl_.address();
> }
>
>
> void address(const boost::asio::ip::address& addr)
> {
> impl_.address(addr);
> }
>
>
> friend bool operator==(const basic_endpoint<InternetProtocol>& e1,
> const basic_endpoint<InternetProtocol>& e2)
> {
> return e1.impl_ == e2.impl_;
> }
>
>
> friend bool operator!=(const basic_endpoint<InternetProtocol>& e1,
> const basic_endpoint<InternetProtocol>& e2)
> {
> return !(e1 == e2);
> }
>
>
> friend bool operator<(const basic_endpoint<InternetProtocol>& e1,
> const basic_endpoint<InternetProtocol>& e2)
> {
> return e1.impl_ < e2.impl_;
> }
>
>
> friend bool operator>(const basic_endpoint<InternetProtocol>& e1,
> const basic_endpoint<InternetProtocol>& e2)
> {
> return e2.impl_ < e1.impl_;
> }
>
>
> friend bool operator<=(const basic_endpoint<InternetProtocol>& e1,
> const basic_endpoint<InternetProtocol>& e2)
> {
> return !(e2 < e1);
> }
>
>
> friend bool operator>=(const basic_endpoint<InternetProtocol>& e1,
> const basic_endpoint<InternetProtocol>& e2)
> {
> return !(e1 < e2);
> }
>
>private:
>
> boost::asio::ip::detail::endpoint impl_;
>};
># 250 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 3 4
>template <typename Elem, typename Traits, typename InternetProtocol>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os,
> const basic_endpoint<InternetProtocol>& endpoint);
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 262 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/impl/basic_endpoint.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/impl/basic_endpoint.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ip/impl/basic_endpoint.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>template <typename Elem, typename Traits, typename InternetProtocol>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os,
> const basic_endpoint<InternetProtocol>& endpoint)
>{
> boost::asio::ip::detail::endpoint tmp_ep(endpoint.address(), endpoint.port());
> boost::system::error_code ec;
> std::string s = tmp_ep.to_string(ec);
> if (ec)
> {
> if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
> boost::asio::detail::throw_error(ec);
> else
> os.setstate(std::basic_ostream<Elem, Traits>::failbit);
> }
> else
> for (std::string::iterator i = s.begin(); i != s.end(); ++i)
> os << os.widen(*i);
> return os;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 54 "/usr/include/boost/asio/ip/impl/basic_endpoint.hpp" 2 3 4
># 264 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 2 3 4
># 63 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/basic_resolver.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
># 1 "/usr/include/boost/asio/ip/basic_resolver_iterator.hpp" 1 3 4
># 19 "/usr/include/boost/asio/ip/basic_resolver_iterator.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/ip/basic_resolver_iterator.hpp" 2 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 21 "/usr/include/boost/asio/ip/basic_resolver_iterator.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/ip/basic_resolver_entry.hpp" 1 3 4
># 21 "/usr/include/boost/asio/ip/basic_resolver_entry.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/basic_resolver_entry.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 36 "/usr/include/boost/asio/ip/basic_resolver_entry.hpp" 3 4
>template <typename InternetProtocol>
>class basic_resolver_entry
>{
>public:
>
> typedef InternetProtocol protocol_type;
>
>
> typedef typename InternetProtocol::endpoint endpoint_type;
>
>
> basic_resolver_entry()
> {
> }
>
>
> basic_resolver_entry(const endpoint_type& ep,
> const std::string& host, const std::string& service)
> : endpoint_(ep),
> host_name_(host),
> service_name_(service)
> {
> }
>
>
> endpoint_type endpoint() const
> {
> return endpoint_;
> }
>
>
> operator endpoint_type() const
> {
> return endpoint_;
> }
>
>
> std::string host_name() const
> {
> return host_name_;
> }
>
>
> std::string service_name() const
> {
> return service_name_;
> }
>
>private:
> endpoint_type endpoint_;
> std::string host_name_;
> std::string service_name_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 95 "/usr/include/boost/asio/ip/basic_resolver_entry.hpp" 2 3 4
># 28 "/usr/include/boost/asio/ip/basic_resolver_iterator.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 30 "/usr/include/boost/asio/ip/basic_resolver_iterator.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 47 "/usr/include/boost/asio/ip/basic_resolver_iterator.hpp" 3 4
>template <typename InternetProtocol>
>class basic_resolver_iterator
>{
>public:
>
> typedef std::ptrdiff_t difference_type;
>
>
> typedef basic_resolver_entry<InternetProtocol> value_type;
>
>
> typedef const basic_resolver_entry<InternetProtocol>* pointer;
>
>
> typedef const basic_resolver_entry<InternetProtocol>& reference;
>
>
> typedef std::forward_iterator_tag iterator_category;
>
>
> basic_resolver_iterator()
> : index_(0)
> {
> }
>
>
> static basic_resolver_iterator create(
> boost::asio::detail::addrinfo_type* address_info,
> const std::string& host_name, const std::string& service_name)
> {
> basic_resolver_iterator iter;
> if (!address_info)
> return iter;
>
> std::string actual_host_name = host_name;
> if (address_info->ai_canonname)
> actual_host_name = address_info->ai_canonname;
>
> iter.values_.reset(new values_type);
>
> while (address_info)
> {
> if (address_info->ai_family == 2
> || address_info->ai_family == 10)
> {
> using namespace std;
> typename InternetProtocol::endpoint endpoint;
> endpoint.resize(static_cast<std::size_t>(address_info->ai_addrlen));
> memcpy(endpoint.data(), address_info->ai_addr,
> address_info->ai_addrlen);
> iter.values_->push_back(
> basic_resolver_entry<InternetProtocol>(endpoint,
> actual_host_name, service_name));
> }
> address_info = address_info->ai_next;
> }
>
> return iter;
> }
>
>
> static basic_resolver_iterator create(
> const typename InternetProtocol::endpoint& endpoint,
> const std::string& host_name, const std::string& service_name)
> {
> basic_resolver_iterator iter;
> iter.values_.reset(new values_type);
> iter.values_->push_back(
> basic_resolver_entry<InternetProtocol>(
> endpoint, host_name, service_name));
> return iter;
> }
>
>
> const basic_resolver_entry<InternetProtocol>& operator*() const
> {
> return dereference();
> }
>
>
> const basic_resolver_entry<InternetProtocol>* operator->() const
> {
> return &dereference();
> }
>
>
> basic_resolver_iterator& operator++()
> {
> increment();
> return *this;
> }
>
>
> basic_resolver_iterator operator++(int)
> {
> basic_resolver_iterator tmp(*this);
> ++*this;
> return tmp;
> }
>
>
> friend bool operator==(const basic_resolver_iterator& a,
> const basic_resolver_iterator& b)
> {
> return a.equal(b);
> }
>
>
> friend bool operator!=(const basic_resolver_iterator& a,
> const basic_resolver_iterator& b)
> {
> return !a.equal(b);
> }
>
>private:
> void increment()
> {
> if (++index_ == values_->size())
> {
>
> values_.reset();
> index_ = 0;
> }
> }
>
> bool equal(const basic_resolver_iterator& other) const
> {
> if (!values_ && !other.values_)
> return true;
> if (values_ != other.values_)
> return false;
> return index_ == other.index_;
> }
>
> const basic_resolver_entry<InternetProtocol>& dereference() const
> {
> return (*values_)[index_];
> }
>
> typedef std::vector<basic_resolver_entry<InternetProtocol> > values_type;
> boost::asio::detail::shared_ptr<values_type> values_;
> std::size_t index_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 196 "/usr/include/boost/asio/ip/basic_resolver_iterator.hpp" 2 3 4
># 24 "/usr/include/boost/asio/ip/basic_resolver.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 1 3 4
># 21 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
># 1 "/usr/include/boost/asio/ip/resolver_query_base.hpp" 1 3 4
># 21 "/usr/include/boost/asio/ip/resolver_query_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/resolver_query_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>
>
>
>class resolver_query_base
>{
>public:
># 64 "/usr/include/boost/asio/ip/resolver_query_base.hpp" 3 4
> enum flags
> {
> canonical_name = 0x0002,
> passive = 0x0001,
> numeric_host = 0x0004,
>
> numeric_service = 0x0400,
>
>
>
>
>
>
> v4_mapped = 0x0008,
>
>
>
>
> all_matching = 0x0010,
>
>
>
>
> address_configured = 0x0020
>
>
>
> };
>
>
>
> friend flags operator&(flags x, flags y)
> {
> return static_cast<flags>(
> static_cast<unsigned int>(x) & static_cast<unsigned int>(y));
> }
>
> friend flags operator|(flags x, flags y)
> {
> return static_cast<flags>(
> static_cast<unsigned int>(x) | static_cast<unsigned int>(y));
> }
>
> friend flags operator^(flags x, flags y)
> {
> return static_cast<flags>(
> static_cast<unsigned int>(x) ^ static_cast<unsigned int>(y));
> }
>
> friend flags operator~(flags x)
> {
> return static_cast<flags>(static_cast<unsigned int>(~x));
> }
>
> friend flags& operator&=(flags& x, flags y)
> {
> x = x & y;
> return x;
> }
>
> friend flags& operator|=(flags& x, flags y)
> {
> x = x | y;
> return x;
> }
>
> friend flags& operator^=(flags& x, flags y)
> {
> x = x ^ y;
> return x;
> }
>
>
>protected:
>
> ~resolver_query_base()
> {
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 149 "/usr/include/boost/asio/ip/resolver_query_base.hpp" 2 3 4
># 22 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 24 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 38 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
>template <typename InternetProtocol>
>class basic_resolver_query
> : public resolver_query_base
>{
>public:
>
> typedef InternetProtocol protocol_type;
># 63 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
> basic_resolver_query(const std::string& service,
> resolver_query_base::flags resolve_flags = passive | address_configured)
> : hints_(),
> host_name_(),
> service_name_(service)
> {
> typename InternetProtocol::endpoint endpoint;
> hints_.ai_flags = static_cast<int>(resolve_flags);
> hints_.ai_family = 0;
> hints_.ai_socktype = endpoint.protocol().type();
> hints_.ai_protocol = endpoint.protocol().protocol();
> hints_.ai_addrlen = 0;
> hints_.ai_canonname = 0;
> hints_.ai_addr = 0;
> hints_.ai_next = 0;
> }
># 100 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
> basic_resolver_query(const protocol_type& protocol,
> const std::string& service,
> resolver_query_base::flags resolve_flags = passive | address_configured)
> : hints_(),
> host_name_(),
> service_name_(service)
> {
> hints_.ai_flags = static_cast<int>(resolve_flags);
> hints_.ai_family = protocol.family();
> hints_.ai_socktype = protocol.type();
> hints_.ai_protocol = protocol.protocol();
> hints_.ai_addrlen = 0;
> hints_.ai_canonname = 0;
> hints_.ai_addr = 0;
> hints_.ai_next = 0;
> }
># 148 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
> basic_resolver_query(const std::string& host, const std::string& service,
> resolver_query_base::flags resolve_flags = address_configured)
> : hints_(),
> host_name_(host),
> service_name_(service)
> {
> typename InternetProtocol::endpoint endpoint;
> hints_.ai_flags = static_cast<int>(resolve_flags);
> hints_.ai_family = 0;
> hints_.ai_socktype = endpoint.protocol().type();
> hints_.ai_protocol = endpoint.protocol().protocol();
> hints_.ai_addrlen = 0;
> hints_.ai_canonname = 0;
> hints_.ai_addr = 0;
> hints_.ai_next = 0;
> }
># 199 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
> basic_resolver_query(const protocol_type& protocol,
> const std::string& host, const std::string& service,
> resolver_query_base::flags resolve_flags = address_configured)
> : hints_(),
> host_name_(host),
> service_name_(service)
> {
> hints_.ai_flags = static_cast<int>(resolve_flags);
> hints_.ai_family = protocol.family();
> hints_.ai_socktype = protocol.type();
> hints_.ai_protocol = protocol.protocol();
> hints_.ai_addrlen = 0;
> hints_.ai_canonname = 0;
> hints_.ai_addr = 0;
> hints_.ai_next = 0;
> }
>
>
> const boost::asio::detail::addrinfo_type& hints() const
> {
> return hints_;
> }
>
>
> std::string host_name() const
> {
> return host_name_;
> }
>
>
> std::string service_name() const
> {
> return service_name_;
> }
>
>private:
> boost::asio::detail::addrinfo_type hints_;
> std::string host_name_;
> std::string service_name_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 245 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 2 3 4
># 25 "/usr/include/boost/asio/ip/basic_resolver.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/resolver_service.hpp" 1 3 4
># 21 "/usr/include/boost/asio/ip/resolver_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/resolver_service.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/resolver_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/resolve_endpoint_op.hpp" 1 3 4
># 30 "/usr/include/boost/asio/detail/resolve_endpoint_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 31 "/usr/include/boost/asio/detail/resolve_endpoint_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Protocol, typename Handler>
>class resolve_endpoint_op : public operation
>{
>public:
> struct ptr { Handler* h; void* v; resolve_endpoint_op* p; ~ptr() { reset(); } void reset() { if (p) { p->~resolve_endpoint_op(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(resolve_endpoint_op), *h); v = 0; } } };
>
> typedef typename Protocol::endpoint endpoint_type;
> typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
>
> resolve_endpoint_op(socket_ops::weak_cancel_token_type cancel_token,
> const endpoint_type& endpoint, io_service_impl& ios, Handler& handler)
> : operation(&resolve_endpoint_op::do_complete),
> cancel_token_(cancel_token),
> endpoint_(endpoint),
> io_service_impl_(ios),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
> static void do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> resolve_endpoint_op* o(static_cast<resolve_endpoint_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
>
> if (owner && owner != &o->io_service_impl_)
> {
>
>
>
>
> char host_name[1025];
> char service_name[32];
> socket_ops::background_getnameinfo(o->cancel_token_, o->endpoint_.data(),
> o->endpoint_.size(), host_name, 1025, service_name, 32,
> o->endpoint_.protocol().type(), o->ec_);
> o->iter_ = iterator_type::create(o->endpoint_, host_name, service_name);
>
>
> o->io_service_impl_.post_deferred_completion(o);
> p.v = p.p = 0;
> }
> else
> {
>
>
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, iterator_type>
> handler(o->handler_, o->ec_, o->iter_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
> (void)0;
> }
> }
> }
>
>private:
> socket_ops::weak_cancel_token_type cancel_token_;
> endpoint_type endpoint_;
> io_service_impl& io_service_impl_;
> Handler handler_;
> boost::system::error_code ec_;
> iterator_type iter_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 122 "/usr/include/boost/asio/detail/resolve_endpoint_op.hpp" 2 3 4
># 23 "/usr/include/boost/asio/detail/resolver_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/resolve_op.hpp" 1 3 4
># 31 "/usr/include/boost/asio/detail/resolve_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 32 "/usr/include/boost/asio/detail/resolve_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Protocol, typename Handler>
>class resolve_op : public operation
>{
>public:
> struct ptr { Handler* h; void* v; resolve_op* p; ~ptr() { reset(); } void reset() { if (p) { p->~resolve_op(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(resolve_op), *h); v = 0; } } };
>
> typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
> typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
>
> resolve_op(socket_ops::weak_cancel_token_type cancel_token,
> const query_type& query, io_service_impl& ios, Handler& handler)
> : operation(&resolve_op::do_complete),
> cancel_token_(cancel_token),
> query_(query),
> io_service_impl_(ios),
> handler_(static_cast<Handler&&>(handler)),
> addrinfo_(0)
> {
> }
>
> ~resolve_op()
> {
> if (addrinfo_)
> socket_ops::freeaddrinfo(addrinfo_);
> }
>
> static void do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> resolve_op* o(static_cast<resolve_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
>
> if (owner && owner != &o->io_service_impl_)
> {
>
>
>
>
> socket_ops::background_getaddrinfo(o->cancel_token_,
> o->query_.host_name().c_str(), o->query_.service_name().c_str(),
> o->query_.hints(), &o->addrinfo_, o->ec_);
>
>
> o->io_service_impl_.post_deferred_completion(o);
> p.v = p.p = 0;
> }
> else
> {
>
>
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, iterator_type>
> handler(o->handler_, o->ec_, iterator_type());
> p.h = boost::asio::detail::addressof(handler.handler_);
> if (o->addrinfo_)
> {
> handler.arg2_ = iterator_type::create(o->addrinfo_,
> o->query_.host_name(), o->query_.service_name());
> }
> p.reset();
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
> (void)0;
> }
> }
> }
>
>private:
> socket_ops::weak_cancel_token_type cancel_token_;
> query_type query_;
> io_service_impl& io_service_impl_;
> Handler handler_;
> boost::system::error_code ec_;
> boost::asio::detail::addrinfo_type* addrinfo_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 132 "/usr/include/boost/asio/detail/resolve_op.hpp" 2 3 4
># 24 "/usr/include/boost/asio/detail/resolver_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/resolver_service_base.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/resolver_service_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/thread.hpp" 1 3 4
># 29 "/usr/include/boost/asio/detail/thread.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_thread.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/posix_thread.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/posix_thread.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>extern "C"
>{
> inline void* boost_asio_detail_posix_thread_function(void* arg);
>}
>
>class posix_thread
> : private noncopyable
>{
>public:
>
> template <typename Function>
> posix_thread(Function f, unsigned int = 0)
> : joined_(false)
> {
> start_thread(new func<Function>(f));
> }
>
>
> inline ~posix_thread();
>
>
> inline void join();
>
>private:
> friend void* boost_asio_detail_posix_thread_function(void* arg);
>
> class func_base
> {
> public:
> virtual ~func_base() {}
> virtual void run() = 0;
> };
>
> struct auto_func_base_ptr
> {
> func_base* ptr;
> ~auto_func_base_ptr() { delete ptr; }
> };
>
> template <typename Function>
> class func
> : public func_base
> {
> public:
> func(Function f)
> : f_(f)
> {
> }
>
> virtual void run()
> {
> f_();
> }
>
> private:
> Function f_;
> };
>
> inline void start_thread(func_base* arg);
>
> ::pthread_t thread_;
> bool joined_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 100 "/usr/include/boost/asio/detail/posix_thread.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/posix_thread.ipp" 1 3 4
># 22 "/usr/include/boost/asio/detail/impl/posix_thread.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_thread.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/impl/posix_thread.ipp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/impl/posix_thread.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>posix_thread::~posix_thread()
>{
> if (!joined_)
> ::pthread_detach(thread_);
>}
>
>void posix_thread::join()
>{
> if (!joined_)
> {
> ::pthread_join(thread_, 0);
> joined_ = true;
> }
>}
>
>void posix_thread::start_thread(func_base* arg)
>{
> int error = ::pthread_create(&thread_, 0,
> boost_asio_detail_posix_thread_function, arg);
> if (error != 0)
> {
> delete arg;
> boost::system::error_code ec(error,
> boost::asio::error::get_system_category());
> boost::asio::detail::throw_error(ec, "thread");
> }
>}
>
>void* boost_asio_detail_posix_thread_function(void* arg)
>{
> posix_thread::auto_func_base_ptr func = {
> static_cast<posix_thread::func_base*>(arg) };
> func.ptr->run();
> return 0;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 73 "/usr/include/boost/asio/detail/impl/posix_thread.ipp" 2 3 4
># 103 "/usr/include/boost/asio/detail/posix_thread.hpp" 2 3 4
># 30 "/usr/include/boost/asio/detail/thread.hpp" 2 3 4
>
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
># 47 "/usr/include/boost/asio/detail/thread.hpp" 3 4
>typedef posix_thread thread;
>
>
>}
>}
>}
># 28 "/usr/include/boost/asio/detail/resolver_service_base.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 30 "/usr/include/boost/asio/detail/resolver_service_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class resolver_service_base
>{
>public:
>
>
> typedef socket_ops::shared_cancel_token_type implementation_type;
>
>
> inline resolver_service_base(boost::asio::io_service& io_service);
>
>
> inline ~resolver_service_base();
>
>
> inline void shutdown_service();
>
>
> inline void fork_service(
> boost::asio::io_service::fork_event fork_ev);
>
>
> inline void construct(implementation_type& impl);
>
>
> inline void destroy(implementation_type&);
>
>
> inline void cancel(implementation_type& impl);
>
>protected:
>
> inline void start_resolve_op(operation* op);
>
>
> class auto_addrinfo
> : private boost::asio::detail::noncopyable
> {
> public:
> explicit auto_addrinfo(boost::asio::detail::addrinfo_type* ai)
> : ai_(ai)
> {
> }
>
> ~auto_addrinfo()
> {
> if (ai_)
> socket_ops::freeaddrinfo(ai_);
> }
>
> operator boost::asio::detail::addrinfo_type*()
> {
> return ai_;
> }
>
> private:
> boost::asio::detail::addrinfo_type* ai_;
> };
>
>
> class work_io_service_runner;
>
>
> inline void start_work_thread();
>
>
> io_service_impl& io_service_impl_;
>
>private:
>
> boost::asio::detail::mutex mutex_;
>
>
> boost::asio::detail::scoped_ptr<boost::asio::io_service> work_io_service_;
>
>
> io_service_impl& work_io_service_impl_;
>
>
> boost::asio::detail::scoped_ptr<boost::asio::io_service::work> work_;
>
>
> boost::asio::detail::scoped_ptr<boost::asio::detail::thread> work_thread_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 124 "/usr/include/boost/asio/detail/resolver_service_base.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/resolver_service_base.ipp" 1 3 4
># 19 "/usr/include/boost/asio/detail/impl/resolver_service_base.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/resolver_service_base.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/resolver_service_base.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/impl/resolver_service_base.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class resolver_service_base::work_io_service_runner
>{
>public:
> work_io_service_runner(boost::asio::io_service& io_service)
> : io_service_(io_service) {}
> void operator()() { io_service_.run(); }
>private:
> boost::asio::io_service& io_service_;
>};
>
>resolver_service_base::resolver_service_base(
> boost::asio::io_service& io_service)
> : io_service_impl_(boost::asio::use_service<io_service_impl>(io_service)),
> work_io_service_(new boost::asio::io_service),
> work_io_service_impl_(boost::asio::use_service<
> io_service_impl>(*work_io_service_)),
> work_(new boost::asio::io_service::work(*work_io_service_)),
> work_thread_(0)
>{
>}
>
>resolver_service_base::~resolver_service_base()
>{
> shutdown_service();
>}
>
>void resolver_service_base::shutdown_service()
>{
> work_.reset();
> if (work_io_service_.get())
> {
> work_io_service_->stop();
> if (work_thread_.get())
> {
> work_thread_->join();
> work_thread_.reset();
> }
> work_io_service_.reset();
> }
>}
>
>void resolver_service_base::fork_service(
> boost::asio::io_service::fork_event fork_ev)
>{
> if (work_thread_.get())
> {
> if (fork_ev == boost::asio::io_service::fork_prepare)
> {
> work_io_service_->stop();
> work_thread_->join();
> }
> else
> {
> work_io_service_->reset();
> work_thread_.reset(new boost::asio::detail::thread(
> work_io_service_runner(*work_io_service_)));
> }
> }
>}
>
>void resolver_service_base::construct(
> resolver_service_base::implementation_type& impl)
>{
> impl.reset(static_cast<void*>(0), socket_ops::noop_deleter());
>}
>
>void resolver_service_base::destroy(
> resolver_service_base::implementation_type& impl)
>{
> (void)0;
>
> impl.reset();
>}
>
>void resolver_service_base::cancel(
> resolver_service_base::implementation_type& impl)
>{
> (void)0;
>
> impl.reset(static_cast<void*>(0), socket_ops::noop_deleter());
>}
>
>void resolver_service_base::start_resolve_op(operation* op)
>{
> start_work_thread();
> io_service_impl_.work_started();
> work_io_service_impl_.post_immediate_completion(op, false);
>}
>
>void resolver_service_base::start_work_thread()
>{
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
> if (!work_thread_.get())
> {
> work_thread_.reset(new boost::asio::detail::thread(
> work_io_service_runner(*work_io_service_)));
> }
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 131 "/usr/include/boost/asio/detail/impl/resolver_service_base.ipp" 2 3 4
># 127 "/usr/include/boost/asio/detail/resolver_service_base.hpp" 2 3 4
># 25 "/usr/include/boost/asio/detail/resolver_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/resolver_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Protocol>
>class resolver_service : public resolver_service_base
>{
>public:
>
>
> typedef socket_ops::shared_cancel_token_type implementation_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
>
>
> typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
>
>
> typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
>
>
> resolver_service(boost::asio::io_service& io_service)
> : resolver_service_base(io_service)
> {
> }
>
>
> iterator_type resolve(implementation_type&, const query_type& query,
> boost::system::error_code& ec)
> {
> boost::asio::detail::addrinfo_type* address_info = 0;
>
> socket_ops::getaddrinfo(query.host_name().c_str(),
> query.service_name().c_str(), query.hints(), &address_info, ec);
> auto_addrinfo auto_address_info(address_info);
>
> return ec ? iterator_type() : iterator_type::create(
> address_info, query.host_name(), query.service_name());
> }
>
>
> template <typename Handler>
> void async_resolve(implementation_type& impl,
> const query_type& query, Handler& handler)
> {
>
> typedef resolve_op<Protocol, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(impl, query, io_service_impl_, handler);
>
> (void)0;
>
> start_resolve_op(p.p);
> p.v = p.p = 0;
> }
>
>
> iterator_type resolve(implementation_type&,
> const endpoint_type& endpoint, boost::system::error_code& ec)
> {
> char host_name[1025];
> char service_name[32];
> socket_ops::sync_getnameinfo(endpoint.data(), endpoint.size(),
> host_name, 1025, service_name, 32,
> endpoint.protocol().type(), ec);
>
> return ec ? iterator_type() : iterator_type::create(
> endpoint, host_name, service_name);
> }
>
>
> template <typename Handler>
> void async_resolve(implementation_type& impl,
> const endpoint_type& endpoint, Handler& handler)
> {
>
> typedef resolve_endpoint_op<Protocol, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(impl, endpoint, io_service_impl_, handler);
>
> (void)0;
>
> start_resolve_op(p.p);
> p.v = p.p = 0;
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 125 "/usr/include/boost/asio/detail/resolver_service.hpp" 2 3 4
># 22 "/usr/include/boost/asio/ip/resolver_service.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/ip/resolver_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>
>template <typename InternetProtocol>
>class resolver_service
>
>
>
> : public boost::asio::detail::service_base<
> resolver_service<InternetProtocol> >
>
>{
>public:
>
>
>
>
>
>
> typedef InternetProtocol protocol_type;
>
>
> typedef typename InternetProtocol::endpoint endpoint_type;
>
>
> typedef basic_resolver_query<InternetProtocol> query_type;
>
>
> typedef basic_resolver_iterator<InternetProtocol> iterator_type;
>
>private:
>
> typedef boost::asio::detail::resolver_service<InternetProtocol>
> service_impl_type;
>
>public:
>
>
>
>
> typedef typename service_impl_type::implementation_type implementation_type;
>
>
>
> explicit resolver_service(boost::asio::io_service& io_service)
> : boost::asio::detail::service_base<
> resolver_service<InternetProtocol> >(io_service),
> service_impl_(io_service)
> {
> }
>
>
> void construct(implementation_type& impl)
> {
> service_impl_.construct(impl);
> }
>
>
> void destroy(implementation_type& impl)
> {
> service_impl_.destroy(impl);
> }
>
>
> void cancel(implementation_type& impl)
> {
> service_impl_.cancel(impl);
> }
>
>
> iterator_type resolve(implementation_type& impl, const query_type& query,
> boost::system::error_code& ec)
> {
> return service_impl_.resolve(impl, query, ec);
> }
>
>
> template <typename ResolveHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator_type)>::type>::type
>
> async_resolve(implementation_type& impl, const query_type& query,
> ResolveHandler&& handler)
> {
> boost::asio::detail::async_result_init<
> ResolveHandler, void (boost::system::error_code, iterator_type)> init(
> static_cast<ResolveHandler&&>(handler));
>
> service_impl_.async_resolve(impl, query, init.handler);
>
> return init.result.get();
> }
>
>
> iterator_type resolve(implementation_type& impl,
> const endpoint_type& endpoint, boost::system::error_code& ec)
> {
> return service_impl_.resolve(impl, endpoint, ec);
> }
>
>
> template <typename ResolveHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator_type)>::type>::type
>
> async_resolve(implementation_type& impl, const endpoint_type& endpoint,
> ResolveHandler&& handler)
> {
> boost::asio::detail::async_result_init<
> ResolveHandler, void (boost::system::error_code, iterator_type)> init(
> static_cast<ResolveHandler&&>(handler));
>
> service_impl_.async_resolve(impl, endpoint, init.handler);
>
> return init.result.get();
> }
>
>private:
>
> void shutdown_service()
> {
> service_impl_.shutdown_service();
> }
>
>
> void fork_service(boost::asio::io_service::fork_event event)
> {
> service_impl_.fork_service(event);
> }
>
>
> service_impl_type service_impl_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 167 "/usr/include/boost/asio/ip/resolver_service.hpp" 2 3 4
># 26 "/usr/include/boost/asio/ip/basic_resolver.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/ip/basic_resolver.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 42 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
>template <typename InternetProtocol,
> typename ResolverService = resolver_service<InternetProtocol> >
>class basic_resolver
> : public basic_io_object<ResolverService>
>{
>public:
>
> typedef InternetProtocol protocol_type;
>
>
> typedef typename InternetProtocol::endpoint endpoint_type;
>
>
> typedef basic_resolver_query<InternetProtocol> query;
>
>
> typedef basic_resolver_iterator<InternetProtocol> iterator;
># 67 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> explicit basic_resolver(boost::asio::io_service& io_service)
> : basic_io_object<ResolverService>(io_service)
> {
> }
>
>
>
>
>
>
>
> void cancel()
> {
> return this->service.cancel(this->implementation);
> }
># 99 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> iterator resolve(const query& q)
> {
> boost::system::error_code ec;
> iterator i = this->service.resolve(this->implementation, q, ec);
> boost::asio::detail::throw_error(ec, "resolve");
> return i;
> }
># 124 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> iterator resolve(const query& q, boost::system::error_code& ec)
> {
> return this->service.resolve(this->implementation, q, ec);
> }
># 155 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> template <typename ResolveHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator)>::type>::type
>
> async_resolve(const query& q,
> ResolveHandler&& handler)
> {
>
>
> typedef typename handler_type<ResolveHandler, void(boost::system::error_code, iterator)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const iterator*>(0))) == 1, "ResolveHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const iterator>()), char(0))>
> type_check;
>
> return this->service.async_resolve(this->implementation, q,
> static_cast<ResolveHandler&&>(handler));
> }
># 188 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> iterator resolve(const endpoint_type& e)
> {
> boost::system::error_code ec;
> iterator i = this->service.resolve(this->implementation, e, ec);
> boost::asio::detail::throw_error(ec, "resolve");
> return i;
> }
># 215 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> iterator resolve(const endpoint_type& e, boost::system::error_code& ec)
> {
> return this->service.resolve(this->implementation, e, ec);
> }
># 248 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> template <typename ResolveHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator)>::type>::type
>
> async_resolve(const endpoint_type& e,
> ResolveHandler&& handler)
> {
>
>
> typedef typename handler_type<ResolveHandler, void(boost::system::error_code, iterator)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const iterator*>(0))) == 1, "ResolveHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const iterator>()), char(0))>
> type_check;
>
> return this->service.async_resolve(this->implementation, e,
> static_cast<ResolveHandler&&>(handler));
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 269 "/usr/include/boost/asio/ip/basic_resolver.hpp" 2 3 4
># 64 "/usr/include/boost/asio.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/ip/host_name.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/host_name.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ip/host_name.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>
>inline std::string host_name();
>
>
>inline std::string host_name(boost::system::error_code& ec);
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 39 "/usr/include/boost/asio/ip/host_name.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/ip/impl/host_name.ipp" 1 3 4
># 22 "/usr/include/boost/asio/ip/impl/host_name.ipp" 3 4
># 1 "/usr/include/boost/asio/ip/host_name.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ip/impl/host_name.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 25 "/usr/include/boost/asio/ip/impl/host_name.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>std::string host_name()
>{
> char name[1024];
> boost::system::error_code ec;
> if (boost::asio::detail::socket_ops::gethostname(name, sizeof(name), ec) != 0)
> {
> boost::asio::detail::throw_error(ec);
> return std::string();
> }
> return std::string(name);
>}
>
>std::string host_name(boost::system::error_code& ec)
>{
> char name[1024];
> if (boost::asio::detail::socket_ops::gethostname(name, sizeof(name), ec) != 0)
> return std::string();
> return std::string(name);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 55 "/usr/include/boost/asio/ip/impl/host_name.ipp" 2 3 4
># 42 "/usr/include/boost/asio/ip/host_name.hpp" 2 3 4
># 68 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/icmp.hpp" 1 3 4
># 26 "/usr/include/boost/asio/ip/icmp.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/ip/icmp.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 43 "/usr/include/boost/asio/ip/icmp.hpp" 3 4
>class icmp
>{
>public:
>
> typedef basic_endpoint<icmp> endpoint;
>
>
> static icmp v4()
> {
> return icmp(IPPROTO_ICMP, 2);
> }
>
>
> static icmp v6()
> {
> return icmp(IPPROTO_ICMPV6, 10);
> }
>
>
> int type() const
> {
> return SOCK_RAW;
> }
>
>
> int protocol() const
> {
> return protocol_;
> }
>
>
> int family() const
> {
> return family_;
> }
>
>
> typedef basic_raw_socket<icmp> socket;
>
>
> typedef basic_resolver<icmp> resolver;
>
>
> friend bool operator==(const icmp& p1, const icmp& p2)
> {
> return p1.protocol_ == p2.protocol_ && p1.family_ == p2.family_;
> }
>
>
> friend bool operator!=(const icmp& p1, const icmp& p2)
> {
> return p1.protocol_ != p2.protocol_ || p1.family_ != p2.family_;
> }
>
>private:
>
> explicit icmp(int protocol_id, int protocol_family)
> : protocol_(protocol_id),
> family_(protocol_family)
> {
> }
>
> int protocol_;
> int family_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 114 "/usr/include/boost/asio/ip/icmp.hpp" 2 3 4
># 69 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/multicast.hpp" 1 3 4
># 19 "/usr/include/boost/asio/ip/multicast.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/ip/multicast.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/detail/socket_option.hpp" 1 3 4
># 19 "/usr/include/boost/asio/ip/detail/socket_option.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/ip/detail/socket_option.hpp" 2 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 21 "/usr/include/boost/asio/ip/detail/socket_option.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/ip/detail/socket_option.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>namespace detail {
>namespace socket_option {
>
>
>template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
>class multicast_enable_loopback
>{
>public:
>
>
>
>
>
>
>
> typedef int ipv4_value_type;
> typedef int ipv6_value_type;
>
>
>
> multicast_enable_loopback()
> : ipv4_value_(0),
> ipv6_value_(0)
> {
> }
>
>
> explicit multicast_enable_loopback(bool v)
> : ipv4_value_(v ? 1 : 0),
> ipv6_value_(v ? 1 : 0)
> {
> }
>
>
> multicast_enable_loopback& operator=(bool v)
> {
> ipv4_value_ = v ? 1 : 0;
> ipv6_value_ = v ? 1 : 0;
> return *this;
> }
>
>
> bool value() const
> {
> return !!ipv4_value_;
> }
>
>
> operator bool() const
> {
> return !!ipv4_value_;
> }
>
>
> bool operator!() const
> {
> return !ipv4_value_;
> }
>
>
> template <typename Protocol>
> int level(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Level;
> return IPv4_Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Name;
> return IPv4_Name;
> }
>
>
> template <typename Protocol>
> void* data(const Protocol& protocol)
> {
> if (protocol.family() == 10)
> return &ipv6_value_;
> return &ipv4_value_;
> }
>
>
> template <typename Protocol>
> const void* data(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return &ipv6_value_;
> return &ipv4_value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return sizeof(ipv6_value_);
> return sizeof(ipv4_value_);
> }
>
>
> template <typename Protocol>
> void resize(const Protocol& protocol, std::size_t s)
> {
> if (protocol.family() == 10)
> {
> if (s != sizeof(ipv6_value_))
> {
> std::length_error ex("multicast_enable_loopback socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
> ipv4_value_ = ipv6_value_ ? 1 : 0;
> }
> else
> {
> if (s != sizeof(ipv4_value_))
> {
> std::length_error ex("multicast_enable_loopback socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
> ipv6_value_ = ipv4_value_ ? 1 : 0;
> }
> }
>
>private:
> ipv4_value_type ipv4_value_;
> ipv6_value_type ipv6_value_;
>};
>
>
>template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
>class unicast_hops
>{
>public:
>
> unicast_hops()
> : value_(0)
> {
> }
>
>
> explicit unicast_hops(int v)
> : value_(v)
> {
> }
>
>
> unicast_hops& operator=(int v)
> {
> value_ = v;
> return *this;
> }
>
>
> int value() const
> {
> return value_;
> }
>
>
> template <typename Protocol>
> int level(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Level;
> return IPv4_Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Name;
> return IPv4_Name;
> }
>
>
> template <typename Protocol>
> int* data(const Protocol&)
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> const int* data(const Protocol&) const
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol&) const
> {
> return sizeof(value_);
> }
>
>
> template <typename Protocol>
> void resize(const Protocol&, std::size_t s)
> {
> if (s != sizeof(value_))
> {
> std::length_error ex("unicast hops socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
>
>
>
>
> }
>
>private:
> int value_;
>};
>
>
>template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
>class multicast_hops
>{
>public:
>
>
>
> typedef unsigned char ipv4_value_type;
>
> typedef int ipv6_value_type;
>
>
> multicast_hops()
> : ipv4_value_(0),
> ipv6_value_(0)
> {
> }
>
>
> explicit multicast_hops(int v)
> {
> if (v < 0 || v > 255)
> {
> std::out_of_range ex("multicast hops value out of range");
> boost::asio::detail::throw_exception(ex);
> }
> ipv4_value_ = (ipv4_value_type)v;
> ipv6_value_ = v;
> }
>
>
> multicast_hops& operator=(int v)
> {
> if (v < 0 || v > 255)
> {
> std::out_of_range ex("multicast hops value out of range");
> boost::asio::detail::throw_exception(ex);
> }
> ipv4_value_ = (ipv4_value_type)v;
> ipv6_value_ = v;
> return *this;
> }
>
>
> int value() const
> {
> return ipv6_value_;
> }
>
>
> template <typename Protocol>
> int level(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Level;
> return IPv4_Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Name;
> return IPv4_Name;
> }
>
>
> template <typename Protocol>
> void* data(const Protocol& protocol)
> {
> if (protocol.family() == 10)
> return &ipv6_value_;
> return &ipv4_value_;
> }
>
>
> template <typename Protocol>
> const void* data(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return &ipv6_value_;
> return &ipv4_value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return sizeof(ipv6_value_);
> return sizeof(ipv4_value_);
> }
>
>
> template <typename Protocol>
> void resize(const Protocol& protocol, std::size_t s)
> {
> if (protocol.family() == 10)
> {
> if (s != sizeof(ipv6_value_))
> {
> std::length_error ex("multicast hops socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
> if (ipv6_value_ < 0)
> ipv4_value_ = 0;
> else if (ipv6_value_ > 255)
> ipv4_value_ = 255;
> else
> ipv4_value_ = (ipv4_value_type)ipv6_value_;
> }
> else
> {
> if (s != sizeof(ipv4_value_))
> {
> std::length_error ex("multicast hops socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
> ipv6_value_ = ipv4_value_;
> }
> }
>
>private:
> ipv4_value_type ipv4_value_;
> ipv6_value_type ipv6_value_;
>};
>
>
>template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
>class multicast_request
>{
>public:
>
> multicast_request()
> : ipv4_value_(),
> ipv6_value_()
> {
> }
>
>
> explicit multicast_request(const boost::asio::ip::address& multicast_address)
> : ipv4_value_(),
> ipv6_value_()
> {
> if (multicast_address.is_v6())
> {
> using namespace std;
> boost::asio::ip::address_v6 ipv6_address = multicast_address.to_v6();
> boost::asio::ip::address_v6::bytes_type bytes = ipv6_address.to_bytes();
> memcpy(ipv6_value_.ipv6mr_multiaddr.__in6_u.__u6_addr8, bytes.data(), 16);
> ipv6_value_.ipv6mr_interface = 0;
> }
> else
> {
> ipv4_value_.imr_multiaddr.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> multicast_address.to_v4().to_ulong());
> ipv4_value_.imr_interface.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> boost::asio::ip::address_v4::any().to_ulong());
> }
> }
>
>
> explicit multicast_request(
> const boost::asio::ip::address_v4& multicast_address,
> const boost::asio::ip::address_v4& network_interface
> = boost::asio::ip::address_v4::any())
> : ipv6_value_()
> {
> ipv4_value_.imr_multiaddr.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> multicast_address.to_ulong());
> ipv4_value_.imr_interface.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> network_interface.to_ulong());
> }
>
>
> explicit multicast_request(
> const boost::asio::ip::address_v6& multicast_address,
> unsigned long network_interface = 0)
> : ipv4_value_()
> {
> using namespace std;
> boost::asio::ip::address_v6::bytes_type bytes =
> multicast_address.to_bytes();
> memcpy(ipv6_value_.ipv6mr_multiaddr.__in6_u.__u6_addr8, bytes.data(), 16);
> ipv6_value_.ipv6mr_interface = network_interface;
> }
>
>
> template <typename Protocol>
> int level(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Level;
> return IPv4_Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Name;
> return IPv4_Name;
> }
>
>
> template <typename Protocol>
> const void* data(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return &ipv6_value_;
> return &ipv4_value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return sizeof(ipv6_value_);
> return sizeof(ipv4_value_);
> }
>
>private:
> boost::asio::detail::in4_mreq_type ipv4_value_;
> boost::asio::detail::in6_mreq_type ipv6_value_;
>};
>
>
>template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
>class network_interface
>{
>public:
>
> network_interface()
> {
> ipv4_value_.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> boost::asio::ip::address_v4::any().to_ulong());
> ipv6_value_ = 0;
> }
>
>
> explicit network_interface(const boost::asio::ip::address_v4& ipv4_interface)
> {
> ipv4_value_.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> ipv4_interface.to_ulong());
> ipv6_value_ = 0;
> }
>
>
> explicit network_interface(unsigned int ipv6_interface)
> {
> ipv4_value_.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> boost::asio::ip::address_v4::any().to_ulong());
> ipv6_value_ = ipv6_interface;
> }
>
>
> template <typename Protocol>
> int level(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Level;
> return IPv4_Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Name;
> return IPv4_Name;
> }
>
>
> template <typename Protocol>
> const void* data(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return &ipv6_value_;
> return &ipv4_value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return sizeof(ipv6_value_);
> return sizeof(ipv4_value_);
> }
>
>private:
> boost::asio::detail::in4_addr_type ipv4_value_;
> unsigned int ipv6_value_;
>};
>
>}
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 567 "/usr/include/boost/asio/ip/detail/socket_option.hpp" 2 3 4
># 21 "/usr/include/boost/asio/ip/multicast.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ip/multicast.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>namespace multicast {
># 50 "/usr/include/boost/asio/ip/multicast.hpp" 3 4
>typedef boost::asio::ip::detail::socket_option::multicast_request<
> IPPROTO_IP, 35, IPPROTO_IPV6, 20> join_group;
># 75 "/usr/include/boost/asio/ip/multicast.hpp" 3 4
>typedef boost::asio::ip::detail::socket_option::multicast_request<
> IPPROTO_IP, 36, IPPROTO_IPV6, 21> leave_group;
># 100 "/usr/include/boost/asio/ip/multicast.hpp" 3 4
>typedef boost::asio::ip::detail::socket_option::network_interface<
> IPPROTO_IP, 32, IPPROTO_IPV6, 17>
> outbound_interface;
># 134 "/usr/include/boost/asio/ip/multicast.hpp" 3 4
>typedef boost::asio::ip::detail::socket_option::multicast_hops<
> IPPROTO_IP, 33, IPPROTO_IPV6, 18> hops;
># 168 "/usr/include/boost/asio/ip/multicast.hpp" 3 4
>typedef boost::asio::ip::detail::socket_option::multicast_enable_loopback<
> IPPROTO_IP, 34, IPPROTO_IPV6, 19>
> enable_loopback;
>
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 179 "/usr/include/boost/asio/ip/multicast.hpp" 2 3 4
># 70 "/usr/include/boost/asio.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/ip/tcp.hpp" 1 3 4
># 29 "/usr/include/boost/asio/ip/tcp.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 30 "/usr/include/boost/asio/ip/tcp.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 46 "/usr/include/boost/asio/ip/tcp.hpp" 3 4
>class tcp
>{
>public:
>
> typedef basic_endpoint<tcp> endpoint;
>
>
> static tcp v4()
> {
> return tcp(2);
> }
>
>
> static tcp v6()
> {
> return tcp(10);
> }
>
>
> int type() const
> {
> return SOCK_STREAM;
> }
>
>
> int protocol() const
> {
> return IPPROTO_TCP;
> }
>
>
> int family() const
> {
> return family_;
> }
>
>
> typedef basic_stream_socket<tcp> socket;
>
>
> typedef basic_socket_acceptor<tcp> acceptor;
>
>
> typedef basic_resolver<tcp> resolver;
>
>
>
> typedef basic_socket_iostream<tcp> iostream;
># 125 "/usr/include/boost/asio/ip/tcp.hpp" 3 4
> typedef boost::asio::detail::socket_option::boolean<
> IPPROTO_TCP, 1> no_delay;
>
>
>
> friend bool operator==(const tcp& p1, const tcp& p2)
> {
> return p1.family_ == p2.family_;
> }
>
>
> friend bool operator!=(const tcp& p1, const tcp& p2)
> {
> return p1.family_ != p2.family_;
> }
>
>private:
>
> explicit tcp(int protocol_family)
> : family_(protocol_family)
> {
> }
>
> int family_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 156 "/usr/include/boost/asio/ip/tcp.hpp" 2 3 4
># 73 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/udp.hpp" 1 3 4
># 26 "/usr/include/boost/asio/ip/udp.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/ip/udp.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 43 "/usr/include/boost/asio/ip/udp.hpp" 3 4
>class udp
>{
>public:
>
> typedef basic_endpoint<udp> endpoint;
>
>
> static udp v4()
> {
> return udp(2);
> }
>
>
> static udp v6()
> {
> return udp(10);
> }
>
>
> int type() const
> {
> return SOCK_DGRAM;
> }
>
>
> int protocol() const
> {
> return IPPROTO_UDP;
> }
>
>
> int family() const
> {
> return family_;
> }
>
>
> typedef basic_datagram_socket<udp> socket;
>
>
> typedef basic_resolver<udp> resolver;
>
>
> friend bool operator==(const udp& p1, const udp& p2)
> {
> return p1.family_ == p2.family_;
> }
>
>
> friend bool operator!=(const udp& p1, const udp& p2)
> {
> return p1.family_ != p2.family_;
> }
>
>private:
>
> explicit udp(int protocol_family)
> : family_(protocol_family)
> {
> }
>
> int family_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 112 "/usr/include/boost/asio/ip/udp.hpp" 2 3 4
># 74 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/unicast.hpp" 1 3 4
># 19 "/usr/include/boost/asio/ip/unicast.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/ip/unicast.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ip/unicast.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>namespace unicast {
># 58 "/usr/include/boost/asio/ip/unicast.hpp" 3 4
>typedef boost::asio::ip::detail::socket_option::unicast_hops<
> IPPROTO_IP, 2, IPPROTO_IPV6, 16> hops;
>
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 68 "/usr/include/boost/asio/ip/unicast.hpp" 2 3 4
># 75 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/v6_only.hpp" 1 3 4
># 21 "/usr/include/boost/asio/ip/v6_only.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/v6_only.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 57 "/usr/include/boost/asio/ip/v6_only.hpp" 3 4
>typedef boost::asio::detail::socket_option::boolean<
> IPPROTO_IPV6, 26> v6_only;
>
>
>
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 70 "/usr/include/boost/asio/ip/v6_only.hpp" 2 3 4
># 76 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/is_read_buffered.hpp" 1 3 4
># 22 "/usr/include/boost/asio/is_read_buffered.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/is_read_buffered.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail {
>
>template <typename Stream>
>char is_read_buffered_helper(buffered_stream<Stream>* s);
>
>template <typename Stream>
>char is_read_buffered_helper(buffered_read_stream<Stream>* s);
>
>struct is_read_buffered_big_type { char data[10]; };
>is_read_buffered_big_type is_read_buffered_helper(...);
>
>}
>
>
>
>template <typename Stream>
>class is_read_buffered
>{
>public:
>
>
>
>
>
> static const bool value = sizeof(detail::is_read_buffered_helper((Stream*)0)) == 1
> ;
>
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 60 "/usr/include/boost/asio/is_read_buffered.hpp" 2 3 4
># 77 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/is_write_buffered.hpp" 1 3 4
># 22 "/usr/include/boost/asio/is_write_buffered.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/is_write_buffered.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail {
>
>template <typename Stream>
>char is_write_buffered_helper(buffered_stream<Stream>* s);
>
>template <typename Stream>
>char is_write_buffered_helper(buffered_write_stream<Stream>* s);
>
>struct is_write_buffered_big_type { char data[10]; };
>is_write_buffered_big_type is_write_buffered_helper(...);
>
>}
>
>
>
>template <typename Stream>
>class is_write_buffered
>{
>public:
>
>
>
>
>
> static const bool value = sizeof(detail::is_write_buffered_helper((Stream*)0)) == 1
> ;
>
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 60 "/usr/include/boost/asio/is_write_buffered.hpp" 2 3 4
># 78 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/local/basic_endpoint.hpp" 1 3 4
># 24 "/usr/include/boost/asio/local/basic_endpoint.hpp" 3 4
># 1 "/usr/include/boost/asio/local/detail/endpoint.hpp" 1 3 4
># 23 "/usr/include/boost/asio/local/detail/endpoint.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 24 "/usr/include/boost/asio/local/detail/endpoint.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/local/detail/endpoint.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace local {
>namespace detail {
>
>
>class endpoint
>{
>public:
>
> inline endpoint();
>
>
> inline endpoint(const char* path_name);
>
>
> inline endpoint(const std::string& path_name);
>
>
> endpoint(const endpoint& other)
> : data_(other.data_),
> path_length_(other.path_length_)
> {
> }
>
>
> endpoint& operator=(const endpoint& other)
> {
> data_ = other.data_;
> path_length_ = other.path_length_;
> return *this;
> }
>
>
> boost::asio::detail::socket_addr_type* data()
> {
> return &data_.base;
> }
>
>
> const boost::asio::detail::socket_addr_type* data() const
> {
> return &data_.base;
> }
>
>
> std::size_t size() const
> {
> return path_length_
> + __builtin_offsetof (boost::asio::detail::sockaddr_un_type, sun_path);
> }
>
>
> inline void resize(std::size_t size);
>
>
> std::size_t capacity() const
> {
> return sizeof(boost::asio::detail::sockaddr_un_type);
> }
>
>
> inline std::string path() const;
>
>
> inline void path(const char* p);
>
>
> inline void path(const std::string& p);
>
>
> inline friend bool operator==(
> const endpoint& e1, const endpoint& e2);
>
>
> inline friend bool operator<(
> const endpoint& e1, const endpoint& e2);
>
>private:
>
> union data_union
> {
> boost::asio::detail::socket_addr_type base;
> boost::asio::detail::sockaddr_un_type local;
> } data_;
>
>
> std::size_t path_length_;
>
>
> inline void init(const char* path, std::size_t path_length);
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 128 "/usr/include/boost/asio/local/detail/endpoint.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/local/detail/impl/endpoint.ipp" 1 3 4
># 23 "/usr/include/boost/asio/local/detail/impl/endpoint.ipp" 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 24 "/usr/include/boost/asio/local/detail/impl/endpoint.ipp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/local/detail/endpoint.hpp" 1 3 4
># 28 "/usr/include/boost/asio/local/detail/impl/endpoint.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 30 "/usr/include/boost/asio/local/detail/impl/endpoint.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace local {
>namespace detail {
>
>endpoint::endpoint()
>{
> init("", 0);
>}
>
>endpoint::endpoint(const char* path_name)
>{
> using namespace std;
> init(path_name, strlen(path_name));
>}
>
>endpoint::endpoint(const std::string& path_name)
>{
> init(path_name.data(), path_name.length());
>}
>
>void endpoint::resize(std::size_t new_size)
>{
> if (new_size > sizeof(boost::asio::detail::sockaddr_un_type))
> {
> boost::system::error_code ec(boost::asio::error::invalid_argument);
> boost::asio::detail::throw_error(ec);
> }
> else if (new_size == 0)
> {
> path_length_ = 0;
> }
> else
> {
> path_length_ = new_size
> - __builtin_offsetof (boost::asio::detail::sockaddr_un_type, sun_path);
>
>
> if (path_length_ > 0 && data_.local.sun_path[path_length_ - 1] == 0)
> --path_length_;
> }
>}
>
>std::string endpoint::path() const
>{
> return std::string(data_.local.sun_path, path_length_);
>}
>
>void endpoint::path(const char* p)
>{
> using namespace std;
> init(p, strlen(p));
>}
>
>void endpoint::path(const std::string& p)
>{
> init(p.data(), p.length());
>}
>
>bool operator==(const endpoint& e1, const endpoint& e2)
>{
> return e1.path() == e2.path();
>}
>
>bool operator<(const endpoint& e1, const endpoint& e2)
>{
> return e1.path() < e2.path();
>}
>
>void endpoint::init(const char* path_name, std::size_t path_length)
>{
> if (path_length > sizeof(data_.local.sun_path) - 1)
> {
>
> boost::system::error_code ec(boost::asio::error::name_too_long);
> boost::asio::detail::throw_error(ec);
> }
>
> using namespace std;
> data_.local = boost::asio::detail::sockaddr_un_type();
> data_.local.sun_family = 1;
> memcpy(data_.local.sun_path, path_name, path_length);
> path_length_ = path_length;
>
>
>
> if (path_length > 0 && data_.local.sun_path[0] == 0)
> data_.local.sun_path[path_length] = 0;
>}
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 127 "/usr/include/boost/asio/local/detail/impl/endpoint.ipp" 2 3 4
># 131 "/usr/include/boost/asio/local/detail/endpoint.hpp" 2 3 4
># 25 "/usr/include/boost/asio/local/basic_endpoint.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 31 "/usr/include/boost/asio/local/basic_endpoint.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace local {
># 48 "/usr/include/boost/asio/local/basic_endpoint.hpp" 3 4
>template <typename Protocol>
>class basic_endpoint
>{
>public:
>
> typedef Protocol protocol_type;
>
>
>
>
>
>
> typedef boost::asio::detail::socket_addr_type data_type;
>
>
>
> basic_endpoint()
> {
> }
>
>
> basic_endpoint(const char* path_name)
> : impl_(path_name)
> {
> }
>
>
> basic_endpoint(const std::string& path_name)
> : impl_(path_name)
> {
> }
>
>
> basic_endpoint(const basic_endpoint& other)
> : impl_(other.impl_)
> {
> }
>
>
>
> basic_endpoint(basic_endpoint&& other)
> : impl_(other.impl_)
> {
> }
>
>
>
> basic_endpoint& operator=(const basic_endpoint& other)
> {
> impl_ = other.impl_;
> return *this;
> }
>
>
>
> basic_endpoint& operator=(basic_endpoint&& other)
> {
> impl_ = other.impl_;
> return *this;
> }
>
>
>
> protocol_type protocol() const
> {
> return protocol_type();
> }
>
>
> data_type* data()
> {
> return impl_.data();
> }
>
>
> const data_type* data() const
> {
> return impl_.data();
> }
>
>
> std::size_t size() const
> {
> return impl_.size();
> }
>
>
> void resize(std::size_t new_size)
> {
> impl_.resize(new_size);
> }
>
>
> std::size_t capacity() const
> {
> return impl_.capacity();
> }
>
>
> std::string path() const
> {
> return impl_.path();
> }
>
>
> void path(const char* p)
> {
> impl_.path(p);
> }
>
>
> void path(const std::string& p)
> {
> impl_.path(p);
> }
>
>
> friend bool operator==(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return e1.impl_ == e2.impl_;
> }
>
>
> friend bool operator!=(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return !(e1.impl_ == e2.impl_);
> }
>
>
> friend bool operator<(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return e1.impl_ < e2.impl_;
> }
>
>
> friend bool operator>(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return e2.impl_ < e1.impl_;
> }
>
>
> friend bool operator<=(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return !(e2 < e1);
> }
>
>
> friend bool operator>=(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return !(e1 < e2);
> }
>
>private:
>
> boost::asio::local::detail::endpoint impl_;
>};
># 223 "/usr/include/boost/asio/local/basic_endpoint.hpp" 3 4
>template <typename Elem, typename Traits, typename Protocol>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os,
> const basic_endpoint<Protocol>& endpoint)
>{
> os << endpoint.path();
> return os;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 237 "/usr/include/boost/asio/local/basic_endpoint.hpp" 2 3 4
># 79 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/local/connect_pair.hpp" 1 3 4
># 29 "/usr/include/boost/asio/local/connect_pair.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 30 "/usr/include/boost/asio/local/connect_pair.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace local {
>
>
>template <typename Protocol, typename SocketService1, typename SocketService2>
>void connect_pair(
> basic_socket<Protocol, SocketService1>& socket1,
> basic_socket<Protocol, SocketService2>& socket2);
>
>
>template <typename Protocol, typename SocketService1, typename SocketService2>
>boost::system::error_code connect_pair(
> basic_socket<Protocol, SocketService1>& socket1,
> basic_socket<Protocol, SocketService2>& socket2,
> boost::system::error_code& ec);
>
>template <typename Protocol, typename SocketService1, typename SocketService2>
>inline void connect_pair(
> basic_socket<Protocol, SocketService1>& socket1,
> basic_socket<Protocol, SocketService2>& socket2)
>{
> boost::system::error_code ec;
> connect_pair(socket1, socket2, ec);
> boost::asio::detail::throw_error(ec, "connect_pair");
>}
>
>template <typename Protocol, typename SocketService1, typename SocketService2>
>inline boost::system::error_code connect_pair(
> basic_socket<Protocol, SocketService1>& socket1,
> basic_socket<Protocol, SocketService2>& socket2,
> boost::system::error_code& ec)
>{
>
> boost::asio::local::basic_endpoint<Protocol>* tmp
> = static_cast<typename Protocol::endpoint*>(0);
> (void)tmp;
>
> Protocol protocol;
> boost::asio::detail::socket_type sv[2];
> if (boost::asio::detail::socket_ops::socketpair(protocol.family(),
> protocol.type(), protocol.protocol(), sv, ec)
> == boost::asio::detail::socket_error_retval)
> return ec;
>
> if (socket1.assign(protocol, sv[0], ec))
> {
> boost::system::error_code temp_ec;
> boost::asio::detail::socket_ops::state_type state[2] = { 0, 0 };
> boost::asio::detail::socket_ops::close(sv[0], state[0], true, temp_ec);
> boost::asio::detail::socket_ops::close(sv[1], state[1], true, temp_ec);
> return ec;
> }
>
> if (socket2.assign(protocol, sv[1], ec))
> {
> boost::system::error_code temp_ec;
> socket1.close(temp_ec);
> boost::asio::detail::socket_ops::state_type state = 0;
> boost::asio::detail::socket_ops::close(sv[1], state, true, temp_ec);
> return ec;
> }
>
> return ec;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 102 "/usr/include/boost/asio/local/connect_pair.hpp" 2 3 4
># 80 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/local/datagram_protocol.hpp" 1 3 4
># 27 "/usr/include/boost/asio/local/datagram_protocol.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 28 "/usr/include/boost/asio/local/datagram_protocol.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace local {
># 45 "/usr/include/boost/asio/local/datagram_protocol.hpp" 3 4
>class datagram_protocol
>{
>public:
>
> int type() const
> {
> return SOCK_DGRAM;
> }
>
>
> int protocol() const
> {
> return 0;
> }
>
>
> int family() const
> {
> return 1;
> }
>
>
> typedef basic_endpoint<datagram_protocol> endpoint;
>
>
> typedef basic_datagram_socket<datagram_protocol> socket;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 78 "/usr/include/boost/asio/local/datagram_protocol.hpp" 2 3 4
># 81 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/local/stream_protocol.hpp" 1 3 4
># 29 "/usr/include/boost/asio/local/stream_protocol.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 30 "/usr/include/boost/asio/local/stream_protocol.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace local {
># 47 "/usr/include/boost/asio/local/stream_protocol.hpp" 3 4
>class stream_protocol
>{
>public:
>
> int type() const
> {
> return SOCK_STREAM;
> }
>
>
> int protocol() const
> {
> return 0;
> }
>
>
> int family() const
> {
> return 1;
> }
>
>
> typedef basic_endpoint<stream_protocol> endpoint;
>
>
> typedef basic_stream_socket<stream_protocol> socket;
>
>
> typedef basic_socket_acceptor<stream_protocol> acceptor;
>
>
>
> typedef basic_socket_iostream<stream_protocol> iostream;
>
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 88 "/usr/include/boost/asio/local/stream_protocol.hpp" 2 3 4
># 82 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/placeholders.hpp" 1 3 4
># 21 "/usr/include/boost/asio/placeholders.hpp" 3 4
># 1 "/usr/include/boost/bind/arg.hpp" 1 3 4
># 23 "/usr/include/boost/bind/arg.hpp" 3 4
># 1 "/usr/include/boost/is_placeholder.hpp" 1 3 4
># 21 "/usr/include/boost/is_placeholder.hpp" 3 4
>namespace boost
>{
>
>template< class T > struct is_placeholder
>{
> enum _vt { value = 0 };
>};
>
>}
># 24 "/usr/include/boost/bind/arg.hpp" 2 3 4
>
>
>namespace boost
>{
>
>template< int I > struct arg
>{
> arg()
> {
> }
>
> template< class T > arg( T const & )
> {
> static_assert(I == is_placeholder<T>::value, "I == is_placeholder<T>::value");
> }
>};
>
>template< int I > bool operator==( arg const &, arg const & )
>{
> return true;
>}
>
>
>
>template< int I > struct is_placeholder< arg >
>{
> enum _vt { value = I };
>};
>
>template< int I > struct is_placeholder< arg (*) () >
>{
> enum _vt { value = I };
>};
>
>
>
>}
># 22 "/usr/include/boost/asio/placeholders.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 25 "/usr/include/boost/asio/placeholders.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace placeholders {
># 55 "/usr/include/boost/asio/placeholders.hpp" 3 4
>inline boost::arg<1> error()
>{
> return boost::arg<1>();
>}
>
>inline boost::arg<2> bytes_transferred()
>{
> return boost::arg<2>();
>}
>
>inline boost::arg<2> iterator()
>{
> return boost::arg<2>();
>}
>
>inline boost::arg<2> signal_number()
>{
> return boost::arg<2>();
>}
># 119 "/usr/include/boost/asio/placeholders.hpp" 3 4
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 124 "/usr/include/boost/asio/placeholders.hpp" 2 3 4
># 83 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 1 3 4
># 26 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
># 1 "/usr/include/boost/asio/posix/descriptor_base.hpp" 1 3 4
># 26 "/usr/include/boost/asio/posix/descriptor_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 27 "/usr/include/boost/asio/posix/descriptor_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace posix {
>
>
>
>
>class descriptor_base
>{
>public:
># 57 "/usr/include/boost/asio/posix/descriptor_base.hpp" 3 4
> typedef boost::asio::detail::io_control::non_blocking_io non_blocking_io;
># 80 "/usr/include/boost/asio/posix/descriptor_base.hpp" 3 4
> typedef boost::asio::detail::io_control::bytes_readable bytes_readable;
>
>
>protected:
>
> ~descriptor_base()
> {
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 95 "/usr/include/boost/asio/posix/descriptor_base.hpp" 2 3 4
># 27 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 29 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace posix {
># 43 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
>template <typename DescriptorService>
>class basic_descriptor
> : public basic_io_object<DescriptorService>,
> public descriptor_base
>{
>public:
>
>
> typedef typename DescriptorService::native_handle_type native_type;
>
>
> typedef typename DescriptorService::native_handle_type native_handle_type;
>
>
> typedef basic_descriptor<DescriptorService> lowest_layer_type;
># 67 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> explicit basic_descriptor(boost::asio::io_service& io_service)
> : basic_io_object<DescriptorService>(io_service)
> {
> }
># 85 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> basic_descriptor(boost::asio::io_service& io_service,
> const native_handle_type& native_descriptor)
> : basic_io_object<DescriptorService>(io_service)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> native_descriptor, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 106 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> basic_descriptor(basic_descriptor&& other)
> : basic_io_object<DescriptorService>(
> static_cast<basic_descriptor&&>(other))
> {
> }
># 122 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> basic_descriptor& operator=(basic_descriptor&& other)
> {
> basic_io_object<DescriptorService>::operator=(
> static_cast<basic_descriptor&&>(other));
> return *this;
> }
># 139 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> lowest_layer_type& lowest_layer()
> {
> return *this;
> }
># 153 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> const lowest_layer_type& lowest_layer() const
> {
> return *this;
> }
># 166 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> void assign(const native_handle_type& native_descriptor)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> native_descriptor, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 182 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> boost::system::error_code assign(const native_handle_type& native_descriptor,
> boost::system::error_code& ec)
> {
> return this->get_service().assign(
> this->get_implementation(), native_descriptor, ec);
> }
>
>
> bool is_open() const
> {
> return this->get_service().is_open(this->implementation);
> }
># 204 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> void close()
> {
> boost::system::error_code ec;
> this->get_service().close(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "close");
> }
># 220 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> boost::system::error_code close(boost::system::error_code& ec)
> {
> return this->get_service().close(this->get_implementation(), ec);
> }
># 232 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> native_type native()
> {
> return this->get_service().native_handle(this->implementation);
> }
>
>
>
>
>
>
>
> native_handle_type native_handle()
> {
> return this->get_service().native_handle(this->implementation);
> }
># 258 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> native_handle_type release()
> {
> return this->get_service().release(this->implementation);
> }
># 271 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> void cancel()
> {
> boost::system::error_code ec;
> this->get_service().cancel(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "cancel");
> }
># 286 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> boost::system::error_code cancel(boost::system::error_code& ec)
> {
> return this->get_service().cancel(this->get_implementation(), ec);
> }
># 313 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> template <typename IoControlCommand>
> void io_control(IoControlCommand& command)
> {
> boost::system::error_code ec;
> this->get_service().io_control(this->get_implementation(), command, ec);
> boost::asio::detail::throw_error(ec, "io_control");
> }
># 348 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> template <typename IoControlCommand>
> boost::system::error_code io_control(IoControlCommand& command,
> boost::system::error_code& ec)
> {
> return this->get_service().io_control(
> this->get_implementation(), command, ec);
> }
># 367 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> bool non_blocking() const
> {
> return this->get_service().non_blocking(this->implementation);
> }
># 385 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> void non_blocking(bool mode)
> {
> boost::system::error_code ec;
> this->get_service().non_blocking(this->get_implementation(), mode, ec);
> boost::asio::detail::throw_error(ec, "non_blocking");
> }
># 405 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> boost::system::error_code non_blocking(
> bool mode, boost::system::error_code& ec)
> {
> return this->get_service().non_blocking(
> this->get_implementation(), mode, ec);
> }
># 426 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> bool native_non_blocking() const
> {
> return this->get_service().native_non_blocking(this->implementation);
> }
># 446 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> void native_non_blocking(bool mode)
> {
> boost::system::error_code ec;
> this->get_service().native_non_blocking(
> this->get_implementation(), mode, ec);
> boost::asio::detail::throw_error(ec, "native_non_blocking");
> }
># 469 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 3 4
> boost::system::error_code native_non_blocking(
> bool mode, boost::system::error_code& ec)
> {
> return this->get_service().native_non_blocking(
> this->get_implementation(), mode, ec);
> }
>
>protected:
>
> ~basic_descriptor()
> {
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 488 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 2 3 4
># 84 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 1 3 4
># 23 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 24 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/posix/stream_descriptor_service.hpp" 1 3 4
># 23 "/usr/include/boost/asio/posix/stream_descriptor_service.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 24 "/usr/include/boost/asio/posix/stream_descriptor_service.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 30 "/usr/include/boost/asio/posix/stream_descriptor_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace posix {
>
>
>class stream_descriptor_service
>
>
>
> : public boost::asio::detail::service_base<stream_descriptor_service>
>
>{
>public:
>
>
>
>
>
>private:
>
> typedef detail::reactive_descriptor_service service_impl_type;
>
>public:
>
>
>
>
> typedef service_impl_type::implementation_type implementation_type;
>
>
>
>
>
>
> typedef service_impl_type::native_handle_type native_type;
>
>
>
>
>
>
> typedef service_impl_type::native_handle_type native_handle_type;
>
>
>
> explicit stream_descriptor_service(boost::asio::io_service& io_service)
> : boost::asio::detail::service_base<stream_descriptor_service>(io_service),
> service_impl_(io_service)
> {
> }
>
>
> void construct(implementation_type& impl)
> {
> service_impl_.construct(impl);
> }
>
>
>
> void move_construct(implementation_type& impl,
> implementation_type& other_impl)
> {
> service_impl_.move_construct(impl, other_impl);
> }
>
>
> void move_assign(implementation_type& impl,
> stream_descriptor_service& other_service,
> implementation_type& other_impl)
> {
> service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
> }
>
>
>
> void destroy(implementation_type& impl)
> {
> service_impl_.destroy(impl);
> }
>
>
> boost::system::error_code assign(implementation_type& impl,
> const native_handle_type& native_descriptor,
> boost::system::error_code& ec)
> {
> return service_impl_.assign(impl, native_descriptor, ec);
> }
>
>
> bool is_open(const implementation_type& impl) const
> {
> return service_impl_.is_open(impl);
> }
>
>
> boost::system::error_code close(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.close(impl, ec);
> }
>
>
>
> native_type native(implementation_type& impl)
> {
> return service_impl_.native_handle(impl);
> }
>
>
> native_handle_type native_handle(implementation_type& impl)
> {
> return service_impl_.native_handle(impl);
> }
>
>
> native_handle_type release(implementation_type& impl)
> {
> return service_impl_.release(impl);
> }
>
>
> boost::system::error_code cancel(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return service_impl_.cancel(impl, ec);
> }
>
>
> template <typename IoControlCommand>
> boost::system::error_code io_control(implementation_type& impl,
> IoControlCommand& command, boost::system::error_code& ec)
> {
> return service_impl_.io_control(impl, command, ec);
> }
>
>
> bool non_blocking(const implementation_type& impl) const
> {
> return service_impl_.non_blocking(impl);
> }
>
>
> boost::system::error_code non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> return service_impl_.non_blocking(impl, mode, ec);
> }
>
>
> bool native_non_blocking(const implementation_type& impl) const
> {
> return service_impl_.native_non_blocking(impl);
> }
>
>
> boost::system::error_code native_non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> return service_impl_.native_non_blocking(impl, mode, ec);
> }
>
>
> template <typename ConstBufferSequence>
> std::size_t write_some(implementation_type& impl,
> const ConstBufferSequence& buffers, boost::system::error_code& ec)
> {
> return service_impl_.write_some(impl, buffers, ec);
> }
>
>
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_write_some(implementation_type& impl,
> const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
> boost::asio::detail::async_result_init<
> WriteHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<WriteHandler&&>(handler));
>
> service_impl_.async_write_some(impl, buffers, init.handler);
>
> return init.result.get();
> }
>
>
> template <typename MutableBufferSequence>
> std::size_t read_some(implementation_type& impl,
> const MutableBufferSequence& buffers, boost::system::error_code& ec)
> {
> return service_impl_.read_some(impl, buffers, ec);
> }
>
>
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_read_some(implementation_type& impl,
> const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
> boost::asio::detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> service_impl_.async_read_some(impl, buffers, init.handler);
>
> return init.result.get();
> }
>
>private:
>
> void shutdown_service()
> {
> service_impl_.shutdown_service();
> }
>
>
> service_impl_type service_impl_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 258 "/usr/include/boost/asio/posix/stream_descriptor_service.hpp" 2 3 4
># 29 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 31 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace posix {
># 48 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 3 4
>template <typename StreamDescriptorService = stream_descriptor_service>
>class basic_stream_descriptor
> : public basic_descriptor<StreamDescriptorService>
>{
>public:
>
>
> typedef typename StreamDescriptorService::native_handle_type native_type;
>
>
> typedef typename StreamDescriptorService::native_handle_type
> native_handle_type;
># 71 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 3 4
> explicit basic_stream_descriptor(boost::asio::io_service& io_service)
> : basic_descriptor<StreamDescriptorService>(io_service)
> {
> }
># 89 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 3 4
> basic_stream_descriptor(boost::asio::io_service& io_service,
> const native_handle_type& native_descriptor)
> : basic_descriptor<StreamDescriptorService>(io_service, native_descriptor)
> {
> }
># 106 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 3 4
> basic_stream_descriptor(basic_stream_descriptor&& other)
> : basic_descriptor<StreamDescriptorService>(
> static_cast<basic_stream_descriptor&&>(other))
> {
> }
># 123 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 3 4
> basic_stream_descriptor& operator=(basic_stream_descriptor&& other)
> {
> basic_descriptor<StreamDescriptorService>::operator=(
> static_cast<basic_stream_descriptor&&>(other));
> return *this;
> }
># 158 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().write_some(
> this->get_implementation(), buffers, ec);
> boost::asio::detail::throw_error(ec, "write_some");
> return s;
> }
># 184 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return this->get_service().write_some(
> this->get_implementation(), buffers, ec);
> }
># 227 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_write_some(const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_write_some(this->get_implementation(),
> buffers, static_cast<WriteHandler&&>(handler));
> }
># 269 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().read_some(
> this->get_implementation(), buffers, ec);
> boost::asio::detail::throw_error(ec, "read_some");
> return s;
> }
># 296 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return this->get_service().read_some(
> this->get_implementation(), buffers, ec);
> }
># 340 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
> async_read_some(const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> return this->get_service().async_read_some(this->get_implementation(),
> buffers, static_cast<ReadHandler&&>(handler));
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 360 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 2 3 4
># 85 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/posix/stream_descriptor.hpp" 1 3 4
># 25 "/usr/include/boost/asio/posix/stream_descriptor.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace posix {
>
>
>typedef basic_stream_descriptor<> stream_descriptor;
>
>}
>}
>}
># 87 "/usr/include/boost/asio.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/read.hpp" 1 3 4
># 19 "/usr/include/boost/asio/read.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/read.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 25 "/usr/include/boost/asio/read.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 73 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename MutableBufferSequence>
>std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers);
># 112 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename MutableBufferSequence>
>std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
> boost::system::error_code& ec);
># 162 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition>
>std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition);
># 206 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition>
>std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec);
># 239 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b);
># 268 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
> boost::system::error_code& ec);
># 307 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename Allocator,
> typename CompletionCondition>
>std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition);
># 348 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename Allocator,
> typename CompletionCondition>
>std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition, boost::system::error_code& ec);
># 424 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename AsyncReadStream, typename MutableBufferSequence,
> typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
> ReadHandler&& handler);
># 494 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename AsyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition,
> ReadHandler&& handler);
># 552 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
> ReadHandler&& handler);
># 614 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename AsyncReadStream, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition,
> ReadHandler&& handler);
>
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 630 "/usr/include/boost/asio/read.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/read.hpp" 1 3 4
># 33 "/usr/include/boost/asio/impl/read.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 34 "/usr/include/boost/asio/impl/read.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>template <typename SyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition>
>std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> boost::asio::detail::consuming_buffers<
> mutable_buffer, MutableBufferSequence> tmp(buffers);
> std::size_t total_transferred = 0;
> tmp.prepare(detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred)));
> while (tmp.begin() != tmp.end())
> {
> std::size_t bytes_transferred = s.read_some(tmp, ec);
> tmp.consume(bytes_transferred);
> total_transferred += bytes_transferred;
> tmp.prepare(detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred)));
> }
> return total_transferred;
>}
>
>template <typename SyncReadStream, typename MutableBufferSequence>
>inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read(s, buffers, transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "read");
> return bytes_transferred;
>}
>
>template <typename SyncReadStream, typename MutableBufferSequence>
>inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
>{
> return read(s, buffers, transfer_all(), ec);
>}
>
>template <typename SyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition>
>inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read(s, buffers, completion_condition, ec);
> boost::asio::detail::throw_error(ec, "read");
> return bytes_transferred;
>}
>
>
>
>template <typename SyncReadStream, typename Allocator,
> typename CompletionCondition>
>std::size_t read(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition, boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> std::size_t total_transferred = 0;
> std::size_t max_size = detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred));
> std::size_t bytes_available = read_size_helper(b, max_size);
> while (bytes_available > 0)
> {
> std::size_t bytes_transferred = s.read_some(b.prepare(bytes_available), ec);
> b.commit(bytes_transferred);
> total_transferred += bytes_transferred;
> max_size = detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred));
> bytes_available = read_size_helper(b, max_size);
> }
> return total_transferred;
>}
>
>template <typename SyncReadStream, typename Allocator>
>inline std::size_t read(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read(s, b, transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "read");
> return bytes_transferred;
>}
>
>template <typename SyncReadStream, typename Allocator>
>inline std::size_t read(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> boost::system::error_code& ec)
>{
> return read(s, b, transfer_all(), ec);
>}
>
>template <typename SyncReadStream, typename Allocator,
> typename CompletionCondition>
>inline std::size_t read(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read(s, b, completion_condition, ec);
> boost::asio::detail::throw_error(ec, "read");
> return bytes_transferred;
>}
>
>
>
>namespace detail
>{
> template <typename AsyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition, typename ReadHandler>
> class read_op
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> read_op(AsyncReadStream& stream, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition, ReadHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> stream_(stream),
> buffers_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_op(const read_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> read_op(read_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> switch (start_ = start)
> {
> case 1:
> buffers_.prepare(this->check_for_completion(ec, total_transferred_));
> for (;;)
> {
> stream_.async_read_some(buffers_,
> static_cast<read_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> buffers_.consume(bytes_transferred);
> buffers_.prepare(this->check_for_completion(ec, total_transferred_));
> if ((!ec && bytes_transferred == 0)
> || buffers_.begin() == buffers_.end())
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncReadStream& stream_;
> boost::asio::detail::consuming_buffers<
> mutable_buffer, MutableBufferSequence> buffers_;
> int start_;
> std::size_t total_transferred_;
> ReadHandler handler_;
> };
>
> template <typename AsyncReadStream,
> typename CompletionCondition, typename ReadHandler>
> class read_op<AsyncReadStream, boost::asio::mutable_buffers_1,
> CompletionCondition, ReadHandler>
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> read_op(AsyncReadStream& stream,
> const boost::asio::mutable_buffers_1& buffers,
> CompletionCondition completion_condition, ReadHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> stream_(stream),
> buffer_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_op(const read_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffer_(other.buffer_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> read_op(read_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffer_(other.buffer_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> std::size_t n = 0;
> switch (start_ = start)
> {
> case 1:
> n = this->check_for_completion(ec, total_transferred_);
> for (;;)
> {
> stream_.async_read_some(
> boost::asio::buffer(buffer_ + total_transferred_, n),
> static_cast<read_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> if ((!ec && bytes_transferred == 0)
> || (n = this->check_for_completion(ec, total_transferred_)) == 0
> || total_transferred_ == boost::asio::buffer_size(buffer_))
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncReadStream& stream_;
> boost::asio::mutable_buffer buffer_;
> int start_;
> std::size_t total_transferred_;
> ReadHandler handler_;
> };
>
> template <typename AsyncReadStream, typename Elem,
> typename CompletionCondition, typename ReadHandler>
> class read_op<AsyncReadStream, boost::array<Elem, 2>,
> CompletionCondition, ReadHandler>
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> read_op(AsyncReadStream& stream, const boost::array<Elem, 2>& buffers,
> CompletionCondition completion_condition, ReadHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> stream_(stream),
> buffers_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_op(const read_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> read_op(read_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> typename boost::asio::detail::dependent_type<Elem,
> boost::array<boost::asio::mutable_buffer, 2> >::type bufs = {{
> boost::asio::mutable_buffer(buffers_[0]),
> boost::asio::mutable_buffer(buffers_[1]) }};
> std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
> std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
> std::size_t n = 0;
> switch (start_ = start)
> {
> case 1:
> n = this->check_for_completion(ec, total_transferred_);
> for (;;)
> {
> bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
> bufs[1] = boost::asio::buffer(
> bufs[1] + (total_transferred_ < buffer_size0
> ? 0 : total_transferred_ - buffer_size0),
> n - boost::asio::buffer_size(bufs[0]));
> stream_.async_read_some(bufs, static_cast<read_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> if ((!ec && bytes_transferred == 0)
> || (n = this->check_for_completion(ec, total_transferred_)) == 0
> || total_transferred_ == buffer_size0 + buffer_size1)
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncReadStream& stream_;
> boost::array<Elem, 2> buffers_;
> int start_;
> std::size_t total_transferred_;
> ReadHandler handler_;
> };
>
>
>
> template <typename AsyncReadStream, typename Elem,
> typename CompletionCondition, typename ReadHandler>
> class read_op<AsyncReadStream, std::array<Elem, 2>,
> CompletionCondition, ReadHandler>
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> read_op(AsyncReadStream& stream, const std::array<Elem, 2>& buffers,
> CompletionCondition completion_condition, ReadHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> stream_(stream),
> buffers_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_op(const read_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> read_op(read_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> typename boost::asio::detail::dependent_type<Elem,
> std::array<boost::asio::mutable_buffer, 2> >::type bufs = {{
> boost::asio::mutable_buffer(buffers_[0]),
> boost::asio::mutable_buffer(buffers_[1]) }};
> std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
> std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
> std::size_t n = 0;
> switch (start_ = start)
> {
> case 1:
> n = this->check_for_completion(ec, total_transferred_);
> for (;;)
> {
> bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
> bufs[1] = boost::asio::buffer(
> bufs[1] + (total_transferred_ < buffer_size0
> ? 0 : total_transferred_ - buffer_size0),
> n - boost::asio::buffer_size(bufs[0]));
> stream_.async_read_some(bufs, static_cast<read_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> if ((!ec && bytes_transferred == 0)
> || (n = this->check_for_completion(ec, total_transferred_)) == 0
> || total_transferred_ == buffer_size0 + buffer_size1)
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncReadStream& stream_;
> std::array<Elem, 2> buffers_;
> int start_;
> std::size_t total_transferred_;
> ReadHandler handler_;
> };
>
>
>
> template <typename AsyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition, typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_op<AsyncReadStream, MutableBufferSequence,
> CompletionCondition, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_op<AsyncReadStream, MutableBufferSequence,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition, typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_op<AsyncReadStream, MutableBufferSequence,
> CompletionCondition, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename MutableBufferSequence, typename CompletionCondition,
> typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_op<AsyncReadStream, MutableBufferSequence,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename MutableBufferSequence, typename CompletionCondition,
> typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_op<AsyncReadStream, MutableBufferSequence,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>template <typename AsyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition,
> ReadHandler&& handler)
>{
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> detail::read_op<AsyncReadStream, MutableBufferSequence,
> CompletionCondition, typename handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> s, buffers, completion_condition, init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>template <typename AsyncReadStream, typename MutableBufferSequence,
> typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
> ReadHandler&& handler)
>{
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> detail::read_op<AsyncReadStream, MutableBufferSequence,
> detail::transfer_all_t, typename handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> s, buffers, transfer_all(), init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>
>
>namespace detail
>{
> template <typename AsyncReadStream, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
> class read_streambuf_op
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> read_streambuf_op(AsyncReadStream& stream,
> basic_streambuf<Allocator>& streambuf,
> CompletionCondition completion_condition, ReadHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> stream_(stream),
> streambuf_(streambuf),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_streambuf_op(const read_streambuf_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> streambuf_(other.streambuf_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> read_streambuf_op(read_streambuf_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> streambuf_(other.streambuf_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> std::size_t max_size, bytes_available;
> switch (start_ = start)
> {
> case 1:
> max_size = this->check_for_completion(ec, total_transferred_);
> bytes_available = read_size_helper(streambuf_, max_size);
> for (;;)
> {
> stream_.async_read_some(streambuf_.prepare(bytes_available),
> static_cast<read_streambuf_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> streambuf_.commit(bytes_transferred);
> max_size = this->check_for_completion(ec, total_transferred_);
> bytes_available = read_size_helper(streambuf_, max_size);
> if ((!ec && bytes_transferred == 0) || bytes_available == 0)
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncReadStream& stream_;
> boost::asio::basic_streambuf<Allocator>& streambuf_;
> int start_;
> std::size_t total_transferred_;
> ReadHandler handler_;
> };
>
> template <typename AsyncReadStream, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_streambuf_op<AsyncReadStream, Allocator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_streambuf_op<AsyncReadStream, Allocator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_streambuf_op<AsyncReadStream, Allocator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename Allocator, typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_streambuf_op<AsyncReadStream, Allocator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename Allocator, typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_streambuf_op<AsyncReadStream, Allocator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>template <typename AsyncReadStream, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition,
> ReadHandler&& handler)
>{
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> detail::read_streambuf_op<AsyncReadStream, Allocator,
> CompletionCondition, typename handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> s, b, completion_condition, init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> ReadHandler&& handler)
>{
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> detail::read_streambuf_op<AsyncReadStream, Allocator,
> detail::transfer_all_t, typename handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> s, b, transfer_all(), init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 754 "/usr/include/boost/asio/impl/read.hpp" 2 3 4
># 632 "/usr/include/boost/asio/read.hpp" 2 3 4
># 90 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/read_at.hpp" 1 3 4
># 19 "/usr/include/boost/asio/read_at.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/read_at.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/read_at.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 78 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers);
># 123 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> boost::system::error_code& ec);
># 178 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename CompletionCondition>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition);
># 227 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename CompletionCondition>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec);
># 263 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename Allocator>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, basic_streambuf<Allocator>& b);
># 295 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename Allocator>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, basic_streambuf<Allocator>& b,
> boost::system::error_code& ec);
># 337 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition);
># 381 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition, boost::system::error_code& ec);
># 457 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
> const MutableBufferSequence& buffers,
> ReadHandler&& handler);
># 530 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename CompletionCondition, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_at(AsyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition,
> ReadHandler&& handler);
># 586 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
> basic_streambuf<Allocator>& b, ReadHandler&& handler);
># 646 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_at(AsyncRandomAccessReadDevice& d,
> uint64_t offset, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition,
> ReadHandler&& handler);
>
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 663 "/usr/include/boost/asio/read_at.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/read_at.hpp" 1 3 4
># 33 "/usr/include/boost/asio/impl/read_at.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 34 "/usr/include/boost/asio/impl/read_at.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename CompletionCondition>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> boost::asio::detail::consuming_buffers<
> mutable_buffer, MutableBufferSequence> tmp(buffers);
> std::size_t total_transferred = 0;
> tmp.prepare(detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred)));
> while (tmp.begin() != tmp.end())
> {
> std::size_t bytes_transferred = d.read_some_at(
> offset + total_transferred, tmp, ec);
> tmp.consume(bytes_transferred);
> total_transferred += bytes_transferred;
> tmp.prepare(detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred)));
> }
> return total_transferred;
>}
>
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
>inline std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_at(
> d, offset, buffers, transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "read_at");
> return bytes_transferred;
>}
>
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
>inline std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
>{
> return read_at(d, offset, buffers, transfer_all(), ec);
>}
>
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename CompletionCondition>
>inline std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_at(
> d, offset, buffers, completion_condition, ec);
> boost::asio::detail::throw_error(ec, "read_at");
> return bytes_transferred;
>}
>
>
>
>template <typename SyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition, boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> std::size_t total_transferred = 0;
> std::size_t max_size = detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred));
> std::size_t bytes_available = read_size_helper(b, max_size);
> while (bytes_available > 0)
> {
> std::size_t bytes_transferred = d.read_some_at(
> offset + total_transferred, b.prepare(bytes_available), ec);
> b.commit(bytes_transferred);
> total_transferred += bytes_transferred;
> max_size = detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred));
> bytes_available = read_size_helper(b, max_size);
> }
> return total_transferred;
>}
>
>template <typename SyncRandomAccessReadDevice, typename Allocator>
>inline std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_at(
> d, offset, b, transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "read_at");
> return bytes_transferred;
>}
>
>template <typename SyncRandomAccessReadDevice, typename Allocator>
>inline std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> boost::system::error_code& ec)
>{
> return read_at(d, offset, b, transfer_all(), ec);
>}
>
>template <typename SyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition>
>inline std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_at(
> d, offset, b, completion_condition, ec);
> boost::asio::detail::throw_error(ec, "read_at");
> return bytes_transferred;
>}
>
>
>
>namespace detail
>{
> template <typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename CompletionCondition,
> typename ReadHandler>
> class read_at_op
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> read_at_op(AsyncRandomAccessReadDevice& device,
> uint64_t offset, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition, ReadHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> device_(device),
> offset_(offset),
> buffers_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_at_op(const read_at_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> read_at_op(read_at_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> switch (start_ = start)
> {
> case 1:
> buffers_.prepare(this->check_for_completion(ec, total_transferred_));
> for (;;)
> {
> device_.async_read_some_at(offset_ + total_transferred_,
> buffers_, static_cast<read_at_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> buffers_.consume(bytes_transferred);
> buffers_.prepare(this->check_for_completion(ec, total_transferred_));
> if ((!ec && bytes_transferred == 0)
> || buffers_.begin() == buffers_.end())
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncRandomAccessReadDevice& device_;
> uint64_t offset_;
> boost::asio::detail::consuming_buffers<
> mutable_buffer, MutableBufferSequence> buffers_;
> int start_;
> std::size_t total_transferred_;
> ReadHandler handler_;
> };
>
> template <typename AsyncRandomAccessReadDevice,
> typename CompletionCondition, typename ReadHandler>
> class read_at_op<AsyncRandomAccessReadDevice,
> boost::asio::mutable_buffers_1, CompletionCondition, ReadHandler>
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> read_at_op(AsyncRandomAccessReadDevice& device,
> uint64_t offset, const boost::asio::mutable_buffers_1& buffers,
> CompletionCondition completion_condition, ReadHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> device_(device),
> offset_(offset),
> buffer_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_at_op(const read_at_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffer_(other.buffer_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> read_at_op(read_at_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffer_(other.buffer_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> std::size_t n = 0;
> switch (start_ = start)
> {
> case 1:
> n = this->check_for_completion(ec, total_transferred_);
> for (;;)
> {
> device_.async_read_some_at(offset_ + total_transferred_,
> boost::asio::buffer(buffer_ + total_transferred_, n),
> static_cast<read_at_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> if ((!ec && bytes_transferred == 0)
> || (n = this->check_for_completion(ec, total_transferred_)) == 0
> || total_transferred_ == boost::asio::buffer_size(buffer_))
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncRandomAccessReadDevice& device_;
> uint64_t offset_;
> boost::asio::mutable_buffer buffer_;
> int start_;
> std::size_t total_transferred_;
> ReadHandler handler_;
> };
>
> template <typename AsyncRandomAccessReadDevice, typename Elem,
> typename CompletionCondition, typename ReadHandler>
> class read_at_op<AsyncRandomAccessReadDevice, boost::array<Elem, 2>,
> CompletionCondition, ReadHandler>
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> read_at_op(AsyncRandomAccessReadDevice& device,
> uint64_t offset, const boost::array<Elem, 2>& buffers,
> CompletionCondition completion_condition, ReadHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> device_(device),
> offset_(offset),
> buffers_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_at_op(const read_at_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> read_at_op(read_at_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> typename boost::asio::detail::dependent_type<Elem,
> boost::array<boost::asio::mutable_buffer, 2> >::type bufs = {{
> boost::asio::mutable_buffer(buffers_[0]),
> boost::asio::mutable_buffer(buffers_[1]) }};
> std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
> std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
> std::size_t n = 0;
> switch (start_ = start)
> {
> case 1:
> n = this->check_for_completion(ec, total_transferred_);
> for (;;)
> {
> bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
> bufs[1] = boost::asio::buffer(
> bufs[1] + (total_transferred_ < buffer_size0
> ? 0 : total_transferred_ - buffer_size0),
> n - boost::asio::buffer_size(bufs[0]));
> device_.async_read_some_at(offset_ + total_transferred_,
> bufs, static_cast<read_at_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> if ((!ec && bytes_transferred == 0)
> || (n = this->check_for_completion(ec, total_transferred_)) == 0
> || total_transferred_ == buffer_size0 + buffer_size1)
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncRandomAccessReadDevice& device_;
> uint64_t offset_;
> boost::array<Elem, 2> buffers_;
> int start_;
> std::size_t total_transferred_;
> ReadHandler handler_;
> };
>
>
>
> template <typename AsyncRandomAccessReadDevice, typename Elem,
> typename CompletionCondition, typename ReadHandler>
> class read_at_op<AsyncRandomAccessReadDevice, std::array<Elem, 2>,
> CompletionCondition, ReadHandler>
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> read_at_op(AsyncRandomAccessReadDevice& device,
> uint64_t offset, const std::array<Elem, 2>& buffers,
> CompletionCondition completion_condition, ReadHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> device_(device),
> offset_(offset),
> buffers_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_at_op(const read_at_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> read_at_op(read_at_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> typename boost::asio::detail::dependent_type<Elem,
> std::array<boost::asio::mutable_buffer, 2> >::type bufs = {{
> boost::asio::mutable_buffer(buffers_[0]),
> boost::asio::mutable_buffer(buffers_[1]) }};
> std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
> std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
> std::size_t n = 0;
> switch (start_ = start)
> {
> case 1:
> n = this->check_for_completion(ec, total_transferred_);
> for (;;)
> {
> bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
> bufs[1] = boost::asio::buffer(
> bufs[1] + (total_transferred_ < buffer_size0
> ? 0 : total_transferred_ - buffer_size0),
> n - boost::asio::buffer_size(bufs[0]));
> device_.async_read_some_at(offset_ + total_transferred_,
> bufs, static_cast<read_at_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> if ((!ec && bytes_transferred == 0)
> || (n = this->check_for_completion(ec, total_transferred_)) == 0
> || total_transferred_ == buffer_size0 + buffer_size1)
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncRandomAccessReadDevice& device_;
> uint64_t offset_;
> std::array<Elem, 2> buffers_;
> int start_;
> std::size_t total_transferred_;
> ReadHandler handler_;
> };
>
>
>
> template <typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename CompletionCondition,
> typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
> CompletionCondition, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename CompletionCondition,
> typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename CompletionCondition,
> typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
> CompletionCondition, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename CompletionCondition,
> typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename CompletionCondition,
> typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename CompletionCondition,
> typename ReadHandler>
> inline read_at_op<AsyncRandomAccessReadDevice,
> MutableBufferSequence, CompletionCondition, ReadHandler>
> make_read_at_op(AsyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition, ReadHandler handler)
> {
> return read_at_op<AsyncRandomAccessReadDevice,
> MutableBufferSequence, CompletionCondition, ReadHandler>(
> d, offset, buffers, completion_condition, handler);
> }
>}
>
>template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename CompletionCondition, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_at(AsyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition,
> ReadHandler&& handler)
>{
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
> CompletionCondition, typename handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> d, offset, buffers, completion_condition, init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_at(AsyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> ReadHandler&& handler)
>{
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
> detail::transfer_all_t, typename handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> d, offset, buffers, transfer_all(), init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>
>
>namespace detail
>{
> template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
> class read_at_streambuf_op
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> read_at_streambuf_op(AsyncRandomAccessReadDevice& device,
> uint64_t offset, basic_streambuf<Allocator>& streambuf,
> CompletionCondition completion_condition, ReadHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> device_(device),
> offset_(offset),
> streambuf_(streambuf),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_at_streambuf_op(const read_at_streambuf_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> streambuf_(other.streambuf_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> read_at_streambuf_op(read_at_streambuf_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> streambuf_(other.streambuf_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> std::size_t max_size, bytes_available;
> switch (start_ = start)
> {
> case 1:
> max_size = this->check_for_completion(ec, total_transferred_);
> bytes_available = read_size_helper(streambuf_, max_size);
> for (;;)
> {
> device_.async_read_some_at(offset_ + total_transferred_,
> streambuf_.prepare(bytes_available),
> static_cast<read_at_streambuf_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> streambuf_.commit(bytes_transferred);
> max_size = this->check_for_completion(ec, total_transferred_);
> bytes_available = read_size_helper(streambuf_, max_size);
> if ((!ec && bytes_transferred == 0) || bytes_available == 0)
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncRandomAccessReadDevice& device_;
> uint64_t offset_;
> boost::asio::basic_streambuf<Allocator>& streambuf_;
> int start_;
> std::size_t total_transferred_;
> ReadHandler handler_;
> };
>
> template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncRandomAccessReadDevice,
> typename Allocator, typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncRandomAccessReadDevice,
> typename Allocator, typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_at(AsyncRandomAccessReadDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition,
> ReadHandler&& handler)
>{
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
> CompletionCondition, typename handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> d, offset, b, completion_condition, init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_at(AsyncRandomAccessReadDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> ReadHandler&& handler)
>{
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
> detail::transfer_all_t, typename handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> d, offset, b, transfer_all(), init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 811 "/usr/include/boost/asio/impl/read_at.hpp" 2 3 4
># 665 "/usr/include/boost/asio/read_at.hpp" 2 3 4
># 91 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/read_until.hpp" 1 3 4
># 22 "/usr/include/boost/asio/read_until.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 23 "/usr/include/boost/asio/read_until.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/regex_fwd.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/regex_fwd.hpp" 3 4
># 1 "/usr/include/boost/regex_fwd.hpp" 1 3 4
># 24 "/usr/include/boost/regex_fwd.hpp" 3 4
># 1 "/usr/include/boost/regex/config.hpp" 1 3 4
># 41 "/usr/include/boost/regex/config.hpp" 3 4
># 1 "/usr/include/boost/regex/user.hpp" 1 3 4
># 42 "/usr/include/boost/regex/config.hpp" 2 3 4
># 121 "/usr/include/boost/regex/config.hpp" 3 4
># 1 "/usr/include/boost/regex/config/cwchar.hpp" 1 3 4
># 22 "/usr/include/boost/regex/config/cwchar.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cwchar" 1 3 4
># 39 "/usr/include/c++/4.8.2/cwchar" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cwchar" 3
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 45 "/usr/include/c++/4.8.2/cwchar" 2 3
># 23 "/usr/include/boost/regex/config/cwchar.hpp" 2 3 4
># 1 "/usr/include/c++/4.8.2/cwctype" 1 3 4
># 39 "/usr/include/c++/4.8.2/cwctype" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cwctype" 3
># 24 "/usr/include/boost/regex/config/cwchar.hpp" 2 3 4
># 49 "/usr/include/boost/regex/config/cwchar.hpp" 3 4
>namespace std{
>
>
>extern "C"{
># 201 "/usr/include/boost/regex/config/cwchar.hpp" 3 4
>}
>
>
>}
># 122 "/usr/include/boost/regex/config.hpp" 2 3 4
># 218 "/usr/include/boost/regex/config.hpp" 3 4
># 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
># 219 "/usr/include/boost/regex/config.hpp" 2 3 4
># 390 "/usr/include/boost/regex/config.hpp" 3 4
>namespace boost{ namespace re_detail{
>
> void* get_mem_block();
> void put_mem_block(void*);
>
>}}
># 25 "/usr/include/boost/regex_fwd.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/regex_fwd.hpp" 1 3 4
># 37 "/usr/include/boost/regex/v4/regex_fwd.hpp" 3 4
>namespace boost{
>
>template <class charT>
>class cpp_regex_traits;
>template <class charT>
>struct c_regex_traits;
>template <class charT>
>class w32_regex_traits;
>
>
>
>
>
>template <class charT, class implementationT = cpp_regex_traits<charT> >
>struct regex_traits;
>
>
>
>
>
>template <class charT, class traits = regex_traits<charT> >
>class basic_regex;
>
>typedef basic_regex<char, regex_traits<char> > regex;
>
>typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
>
>
>}
># 28 "/usr/include/boost/regex_fwd.hpp" 2 3 4
># 21 "/usr/include/boost/asio/detail/regex_fwd.hpp" 2 3 4
># 1 "/usr/include/boost/regex/v4/match_flags.hpp" 1 3 4
># 23 "/usr/include/boost/regex/v4/match_flags.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 24 "/usr/include/boost/regex/v4/match_flags.hpp" 2 3 4
>
>
>
>namespace boost{
> namespace regex_constants{
>
>
>typedef enum _match_flags
>{
> match_default = 0,
> match_not_bol = 1,
> match_not_eol = match_not_bol << 1,
> match_not_bob = match_not_eol << 1,
> match_not_eob = match_not_bob << 1,
> match_not_bow = match_not_eob << 1,
> match_not_eow = match_not_bow << 1,
> match_not_dot_newline = match_not_eow << 1,
> match_not_dot_null = match_not_dot_newline << 1,
> match_prev_avail = match_not_dot_null << 1,
> match_init = match_prev_avail << 1,
> match_any = match_init << 1,
> match_not_null = match_any << 1,
> match_continuous = match_not_null << 1,
>
> match_partial = match_continuous << 1,
>
> match_stop = match_partial << 1,
> match_not_initial_null = match_stop,
> match_all = match_stop << 1,
> match_perl = match_all << 1,
> match_posix = match_perl << 1,
> match_nosubs = match_posix << 1,
> match_extra = match_nosubs << 1,
> match_single_line = match_extra << 1,
> match_unused1 = match_single_line << 1,
> match_unused2 = match_unused1 << 1,
> match_unused3 = match_unused2 << 1,
> match_max = match_unused3,
>
> format_perl = 0,
> format_default = 0,
> format_sed = match_max << 1,
> format_all = format_sed << 1,
> format_no_copy = format_all << 1,
> format_first_only = format_no_copy << 1,
> format_is_if = format_first_only << 1,
> format_literal = format_is_if << 1
>
>} match_flags;
>
>
>
>
>typedef match_flags match_flag_type;
>
>
>
>inline match_flags operator&(match_flags m1, match_flags m2)
>{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) & static_cast<boost::int32_t>(m2)); }
>inline match_flags operator|(match_flags m1, match_flags m2)
>{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) | static_cast<boost::int32_t>(m2)); }
>inline match_flags operator^(match_flags m1, match_flags m2)
>{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) ^ static_cast<boost::int32_t>(m2)); }
>inline match_flags operator~(match_flags m1)
>{ return static_cast<match_flags>(~static_cast<boost::int32_t>(m1)); }
>inline match_flags& operator&=(match_flags& m1, match_flags m2)
>{ m1 = m1&m2; return m1; }
>inline match_flags& operator|=(match_flags& m1, match_flags m2)
>{ m1 = m1|m2; return m1; }
>inline match_flags& operator^=(match_flags& m1, match_flags m2)
>{ m1 = m1^m2; return m1; }
>
>
>
>
>}
>
>
>
>using regex_constants::match_flag_type;
>using regex_constants::match_default;
>using regex_constants::match_not_bol;
>using regex_constants::match_not_eol;
>using regex_constants::match_not_bob;
>using regex_constants::match_not_eob;
>using regex_constants::match_not_bow;
>using regex_constants::match_not_eow;
>using regex_constants::match_not_dot_newline;
>using regex_constants::match_not_dot_null;
>using regex_constants::match_prev_avail;
>
>using regex_constants::match_any;
>using regex_constants::match_not_null;
>using regex_constants::match_continuous;
>using regex_constants::match_partial;
>
>using regex_constants::match_all;
>using regex_constants::match_perl;
>using regex_constants::match_posix;
>using regex_constants::match_nosubs;
>using regex_constants::match_extra;
>using regex_constants::match_single_line;
>
>using regex_constants::format_all;
>using regex_constants::format_sed;
>using regex_constants::format_perl;
>using regex_constants::format_default;
>using regex_constants::format_no_copy;
>using regex_constants::format_first_only;
>
>
>}
># 22 "/usr/include/boost/asio/detail/regex_fwd.hpp" 2 3 4
>
>namespace boost {
>
>template <class BidiIterator>
>struct sub_match;
>
>template <class BidiIterator, class Allocator>
>class match_results;
>
>}
># 27 "/usr/include/boost/asio/read_until.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 31 "/usr/include/boost/asio/read_until.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail
>{
> char (&has_result_type_helper(...))[2];
>
> template <typename T>
> char has_result_type_helper(T*, typename T::result_type* = 0);
>
> template <typename T>
> struct has_result_type
> {
> enum { value = (sizeof((has_result_type_helper)((T*)(0))) == 1) };
> };
>}
>
>
>
>template <typename T>
>struct is_match_condition
>{
>
>
>
>
> enum
> {
> value = boost::asio::is_function<
> typename boost::asio::remove_pointer<T>::type>::value
> || detail::has_result_type<T>::value
> };
>
>};
># 123 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, char delim);
># 157 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, char delim,
> boost::system::error_code& ec);
># 210 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const std::string& delim);
># 244 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
> boost::system::error_code& ec);
># 302 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr);
># 339 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
> boost::system::error_code& ec);
># 446 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator, typename MatchCondition>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
> typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
># 501 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator, typename MatchCondition>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> MatchCondition match_condition, boost::system::error_code& ec,
> typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
># 595 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> char delim, ReadHandler&& handler);
># 680 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
> ReadHandler&& handler);
># 772 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
> ReadHandler&& handler);
># 905 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename AsyncReadStream, typename Allocator,
> typename MatchCondition, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> MatchCondition match_condition, ReadHandler&& handler,
> typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 920 "/usr/include/boost/asio/read_until.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/read_until.hpp" 1 3 4
># 32 "/usr/include/boost/asio/impl/read_until.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 33 "/usr/include/boost/asio/impl/read_until.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>template <typename SyncReadStream, typename Allocator>
>inline std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, char delim)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_until(s, b, delim, ec);
> boost::asio::detail::throw_error(ec, "read_until");
> return bytes_transferred;
>}
>
>template <typename SyncReadStream, typename Allocator>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, char delim,
> boost::system::error_code& ec)
>{
> std::size_t search_position = 0;
> for (;;)
> {
>
> typedef typename boost::asio::basic_streambuf<
> Allocator>::const_buffers_type const_buffers_type;
> typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
> const_buffers_type buffers = b.data();
> iterator begin = iterator::begin(buffers);
> iterator start_pos = begin + search_position;
> iterator end = iterator::end(buffers);
>
>
> iterator iter = std::find(start_pos, end, delim);
> if (iter != end)
> {
>
> ec = boost::system::error_code();
> return iter - begin + 1;
> }
> else
> {
>
> search_position = end - begin;
> }
>
>
> if (b.size() == b.max_size())
> {
> ec = error::not_found;
> return 0;
> }
>
>
> std::size_t bytes_to_read = read_size_helper(b, 65536);
> b.commit(s.read_some(b.prepare(bytes_to_read), ec));
> if (ec)
> return 0;
> }
>}
>
>template <typename SyncReadStream, typename Allocator>
>inline std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const std::string& delim)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_until(s, b, delim, ec);
> boost::asio::detail::throw_error(ec, "read_until");
> return bytes_transferred;
>}
>
>namespace detail
>{
>
>
>
>
>
>
> template <typename Iterator1, typename Iterator2>
> std::pair<Iterator1, bool> partial_search(
> Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
> {
> for (Iterator1 iter1 = first1; iter1 != last1; ++iter1)
> {
> Iterator1 test_iter1 = iter1;
> Iterator2 test_iter2 = first2;
> for (;; ++test_iter1, ++test_iter2)
> {
> if (test_iter2 == last2)
> return std::make_pair(iter1, true);
> if (test_iter1 == last1)
> {
> if (test_iter2 != first2)
> return std::make_pair(iter1, false);
> else
> break;
> }
> if (*test_iter1 != *test_iter2)
> break;
> }
> }
> return std::make_pair(last1, false);
> }
>}
>
>template <typename SyncReadStream, typename Allocator>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
> boost::system::error_code& ec)
>{
> std::size_t search_position = 0;
> for (;;)
> {
>
> typedef typename boost::asio::basic_streambuf<
> Allocator>::const_buffers_type const_buffers_type;
> typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
> const_buffers_type buffers = b.data();
> iterator begin = iterator::begin(buffers);
> iterator start_pos = begin + search_position;
> iterator end = iterator::end(buffers);
>
>
> std::pair<iterator, bool> result = detail::partial_search(
> start_pos, end, delim.begin(), delim.end());
> if (result.first != end)
> {
> if (result.second)
> {
>
> ec = boost::system::error_code();
> return result.first - begin + delim.length();
> }
> else
> {
>
> search_position = result.first - begin;
> }
> }
> else
> {
>
> search_position = end - begin;
> }
>
>
> if (b.size() == b.max_size())
> {
> ec = error::not_found;
> return 0;
> }
>
>
> std::size_t bytes_to_read = read_size_helper(b, 65536);
> b.commit(s.read_some(b.prepare(bytes_to_read), ec));
> if (ec)
> return 0;
> }
>}
>
>
>
>template <typename SyncReadStream, typename Allocator>
>inline std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_until(s, b, expr, ec);
> boost::asio::detail::throw_error(ec, "read_until");
> return bytes_transferred;
>}
>
>template <typename SyncReadStream, typename Allocator>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
> boost::system::error_code& ec)
>{
> std::size_t search_position = 0;
> for (;;)
> {
>
> typedef typename boost::asio::basic_streambuf<
> Allocator>::const_buffers_type const_buffers_type;
> typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
> const_buffers_type buffers = b.data();
> iterator begin = iterator::begin(buffers);
> iterator start_pos = begin + search_position;
> iterator end = iterator::end(buffers);
>
>
> boost::match_results<iterator,
> typename std::vector<boost::sub_match<iterator> >::allocator_type>
> match_results;
> if (regex_search(start_pos, end, match_results, expr,
> boost::match_default | boost::match_partial))
> {
> if (match_results[0].matched)
> {
>
> ec = boost::system::error_code();
> return match_results[0].second - begin;
> }
> else
> {
>
> search_position = match_results[0].first - begin;
> }
> }
> else
> {
>
> search_position = end - begin;
> }
>
>
> if (b.size() == b.max_size())
> {
> ec = error::not_found;
> return 0;
> }
>
>
> std::size_t bytes_to_read = read_size_helper(b, 65536);
> b.commit(s.read_some(b.prepare(bytes_to_read), ec));
> if (ec)
> return 0;
> }
>}
>
>
>
>template <typename SyncReadStream, typename Allocator, typename MatchCondition>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> MatchCondition match_condition, boost::system::error_code& ec,
> typename enable_if<is_match_condition<MatchCondition>::value>::type*)
>{
> std::size_t search_position = 0;
> for (;;)
> {
>
> typedef typename boost::asio::basic_streambuf<
> Allocator>::const_buffers_type const_buffers_type;
> typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
> const_buffers_type buffers = b.data();
> iterator begin = iterator::begin(buffers);
> iterator start_pos = begin + search_position;
> iterator end = iterator::end(buffers);
>
>
> std::pair<iterator, bool> result = match_condition(start_pos, end);
> if (result.second)
> {
>
> ec = boost::system::error_code();
> return result.first - begin;
> }
> else if (result.first != end)
> {
>
> search_position = result.first - begin;
> }
> else
> {
>
> search_position = end - begin;
> }
>
>
> if (b.size() == b.max_size())
> {
> ec = error::not_found;
> return 0;
> }
>
>
> std::size_t bytes_to_read = read_size_helper(b, 65536);
> b.commit(s.read_some(b.prepare(bytes_to_read), ec));
> if (ec)
> return 0;
> }
>}
>
>template <typename SyncReadStream, typename Allocator, typename MatchCondition>
>inline std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
> typename enable_if<is_match_condition<MatchCondition>::value>::type*)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_until(s, b, match_condition, ec);
> boost::asio::detail::throw_error(ec, "read_until");
> return bytes_transferred;
>}
>
>namespace detail
>{
> template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
> class read_until_delim_op
> {
> public:
> read_until_delim_op(AsyncReadStream& stream,
> boost::asio::basic_streambuf<Allocator>& streambuf,
> char delim, ReadHandler& handler)
> : stream_(stream),
> streambuf_(streambuf),
> delim_(delim),
> start_(0),
> search_position_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_until_delim_op(const read_until_delim_op& other)
> : stream_(other.stream_),
> streambuf_(other.streambuf_),
> delim_(other.delim_),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(other.handler_)
> {
> }
>
> read_until_delim_op(read_until_delim_op&& other)
> : stream_(other.stream_),
> streambuf_(other.streambuf_),
> delim_(other.delim_),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
> std::size_t bytes_to_read;
> switch (start_ = start)
> {
> case 1:
> for (;;)
> {
> {
>
> typedef typename boost::asio::basic_streambuf<
> Allocator>::const_buffers_type const_buffers_type;
> typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
> const_buffers_type buffers = streambuf_.data();
> iterator begin = iterator::begin(buffers);
> iterator start_pos = begin + search_position_;
> iterator end = iterator::end(buffers);
>
>
> iterator iter = std::find(start_pos, end, delim_);
> if (iter != end)
> {
>
> search_position_ = iter - begin + 1;
> bytes_to_read = 0;
> }
>
>
> else if (streambuf_.size() == streambuf_.max_size())
> {
> search_position_ = not_found;
> bytes_to_read = 0;
> }
>
>
> else
> {
>
> search_position_ = end - begin;
> bytes_to_read = read_size_helper(streambuf_, 65536);
> }
> }
>
>
> if (!start && bytes_to_read == 0)
> break;
>
>
> stream_.async_read_some(streambuf_.prepare(bytes_to_read),
> static_cast<read_until_delim_op&&>(*this));
> return; default:
> streambuf_.commit(bytes_transferred);
> if (ec || bytes_transferred == 0)
> break;
> }
>
> const boost::system::error_code result_ec =
> (search_position_ == not_found)
> ? error::not_found : ec;
>
> const std::size_t result_n =
> (ec || search_position_ == not_found)
> ? 0 : search_position_;
>
> handler_(result_ec, result_n);
> }
> }
>
>
> AsyncReadStream& stream_;
> boost::asio::basic_streambuf<Allocator>& streambuf_;
> char delim_;
> int start_;
> std::size_t search_position_;
> ReadHandler handler_;
> };
>
> template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_until_delim_op<AsyncReadStream,
> Allocator, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_until_delim_op<AsyncReadStream,
> Allocator, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_until_delim_op<AsyncReadStream,
> Allocator, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream, typename Allocator,
> typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_until_delim_op<AsyncReadStream,
> Allocator, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream, typename Allocator,
> typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_until_delim_op<AsyncReadStream,
> Allocator, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, char delim,
> ReadHandler&& handler)
>{
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> detail::read_until_delim_op<AsyncReadStream,
> Allocator, typename handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> s, b, delim, init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>namespace detail
>{
> template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
> class read_until_delim_string_op
> {
> public:
> read_until_delim_string_op(AsyncReadStream& stream,
> boost::asio::basic_streambuf<Allocator>& streambuf,
> const std::string& delim, ReadHandler& handler)
> : stream_(stream),
> streambuf_(streambuf),
> delim_(delim),
> start_(0),
> search_position_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_until_delim_string_op(const read_until_delim_string_op& other)
> : stream_(other.stream_),
> streambuf_(other.streambuf_),
> delim_(other.delim_),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(other.handler_)
> {
> }
>
> read_until_delim_string_op(read_until_delim_string_op&& other)
> : stream_(other.stream_),
> streambuf_(other.streambuf_),
> delim_(static_cast<std::string&&>(other.delim_)),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
> std::size_t bytes_to_read;
> switch (start_ = start)
> {
> case 1:
> for (;;)
> {
> {
>
> typedef typename boost::asio::basic_streambuf<
> Allocator>::const_buffers_type const_buffers_type;
> typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
> const_buffers_type buffers = streambuf_.data();
> iterator begin = iterator::begin(buffers);
> iterator start_pos = begin + search_position_;
> iterator end = iterator::end(buffers);
>
>
> std::pair<iterator, bool> result = detail::partial_search(
> start_pos, end, delim_.begin(), delim_.end());
> if (result.first != end && result.second)
> {
>
> search_position_ = result.first - begin + delim_.length();
> bytes_to_read = 0;
> }
>
>
> else if (streambuf_.size() == streambuf_.max_size())
> {
> search_position_ = not_found;
> bytes_to_read = 0;
> }
>
>
> else
> {
> if (result.first != end)
> {
>
>
> search_position_ = result.first - begin;
> }
> else
> {
>
> search_position_ = end - begin;
> }
>
> bytes_to_read = read_size_helper(streambuf_, 65536);
> }
> }
>
>
> if (!start && bytes_to_read == 0)
> break;
>
>
> stream_.async_read_some(streambuf_.prepare(bytes_to_read),
> static_cast<read_until_delim_string_op&&>(*this));
> return; default:
> streambuf_.commit(bytes_transferred);
> if (ec || bytes_transferred == 0)
> break;
> }
>
> const boost::system::error_code result_ec =
> (search_position_ == not_found)
> ? error::not_found : ec;
>
> const std::size_t result_n =
> (ec || search_position_ == not_found)
> ? 0 : search_position_;
>
> handler_(result_ec, result_n);
> }
> }
>
>
> AsyncReadStream& stream_;
> boost::asio::basic_streambuf<Allocator>& streambuf_;
> std::string delim_;
> int start_;
> std::size_t search_position_;
> ReadHandler handler_;
> };
>
> template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_until_delim_string_op<AsyncReadStream,
> Allocator, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_until_delim_string_op<AsyncReadStream,
> Allocator, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_until_delim_string_op<AsyncReadStream,
> Allocator, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename Allocator, typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_until_delim_string_op<AsyncReadStream,
> Allocator, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename Allocator, typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_until_delim_string_op<AsyncReadStream,
> Allocator, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
> ReadHandler&& handler)
>{
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> detail::read_until_delim_string_op<AsyncReadStream,
> Allocator, typename handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> s, b, delim, init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>
>
>namespace detail
>{
> template <typename AsyncReadStream, typename Allocator,
> typename RegEx, typename ReadHandler>
> class read_until_expr_op
> {
> public:
> read_until_expr_op(AsyncReadStream& stream,
> boost::asio::basic_streambuf<Allocator>& streambuf,
> const boost::regex& expr, ReadHandler& handler)
> : stream_(stream),
> streambuf_(streambuf),
> expr_(expr),
> start_(0),
> search_position_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_until_expr_op(const read_until_expr_op& other)
> : stream_(other.stream_),
> streambuf_(other.streambuf_),
> expr_(other.expr_),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(other.handler_)
> {
> }
>
> read_until_expr_op(read_until_expr_op&& other)
> : stream_(other.stream_),
> streambuf_(other.streambuf_),
> expr_(other.expr_),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
> std::size_t bytes_to_read;
> switch (start_ = start)
> {
> case 1:
> for (;;)
> {
> {
>
> typedef typename boost::asio::basic_streambuf<
> Allocator>::const_buffers_type const_buffers_type;
> typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
> const_buffers_type buffers = streambuf_.data();
> iterator begin = iterator::begin(buffers);
> iterator start_pos = begin + search_position_;
> iterator end = iterator::end(buffers);
>
>
> boost::match_results<iterator,
> typename std::vector<boost::sub_match<iterator> >::allocator_type>
> match_results;
> bool match = regex_search(start_pos, end, match_results, expr_,
> boost::match_default | boost::match_partial);
> if (match && match_results[0].matched)
> {
>
> search_position_ = match_results[0].second - begin;
> bytes_to_read = 0;
> }
>
>
> else if (streambuf_.size() == streambuf_.max_size())
> {
> search_position_ = not_found;
> bytes_to_read = 0;
> }
>
>
> else
> {
> if (match)
> {
>
>
> search_position_ = match_results[0].first - begin;
> }
> else
> {
>
> search_position_ = end - begin;
> }
>
> bytes_to_read = read_size_helper(streambuf_, 65536);
> }
> }
>
>
> if (!start && bytes_to_read == 0)
> break;
>
>
> stream_.async_read_some(streambuf_.prepare(bytes_to_read),
> static_cast<read_until_expr_op&&>(*this));
> return; default:
> streambuf_.commit(bytes_transferred);
> if (ec || bytes_transferred == 0)
> break;
> }
>
> const boost::system::error_code result_ec =
> (search_position_ == not_found)
> ? error::not_found : ec;
>
> const std::size_t result_n =
> (ec || search_position_ == not_found)
> ? 0 : search_position_;
>
> handler_(result_ec, result_n);
> }
> }
>
>
> AsyncReadStream& stream_;
> boost::asio::basic_streambuf<Allocator>& streambuf_;
> RegEx expr_;
> int start_;
> std::size_t search_position_;
> ReadHandler handler_;
> };
>
> template <typename AsyncReadStream, typename Allocator,
> typename RegEx, typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_until_expr_op<AsyncReadStream,
> Allocator, RegEx, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename Allocator,
> typename RegEx, typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_until_expr_op<AsyncReadStream,
> Allocator, RegEx, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename Allocator,
> typename RegEx, typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_until_expr_op<AsyncReadStream,
> Allocator, RegEx, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream, typename Allocator,
> typename RegEx, typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_until_expr_op<AsyncReadStream,
> Allocator, RegEx, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream, typename Allocator,
> typename RegEx, typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_until_expr_op<AsyncReadStream,
> Allocator, RegEx, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
> ReadHandler&& handler)
>{
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> detail::read_until_expr_op<AsyncReadStream, Allocator,
> boost::regex, typename handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> s, b, expr, init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>
>
>namespace detail
>{
> template <typename AsyncReadStream, typename Allocator,
> typename MatchCondition, typename ReadHandler>
> class read_until_match_op
> {
> public:
> read_until_match_op(AsyncReadStream& stream,
> boost::asio::basic_streambuf<Allocator>& streambuf,
> MatchCondition match_condition, ReadHandler& handler)
> : stream_(stream),
> streambuf_(streambuf),
> match_condition_(match_condition),
> start_(0),
> search_position_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_until_match_op(const read_until_match_op& other)
> : stream_(other.stream_),
> streambuf_(other.streambuf_),
> match_condition_(other.match_condition_),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(other.handler_)
> {
> }
>
> read_until_match_op(read_until_match_op&& other)
> : stream_(other.stream_),
> streambuf_(other.streambuf_),
> match_condition_(other.match_condition_),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
> std::size_t bytes_to_read;
> switch (start_ = start)
> {
> case 1:
> for (;;)
> {
> {
>
> typedef typename boost::asio::basic_streambuf<
> Allocator>::const_buffers_type const_buffers_type;
> typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
> const_buffers_type buffers = streambuf_.data();
> iterator begin = iterator::begin(buffers);
> iterator start_pos = begin + search_position_;
> iterator end = iterator::end(buffers);
>
>
> std::pair<iterator, bool> result = match_condition_(start_pos, end);
> if (result.second)
> {
>
> search_position_ = result.first - begin;
> bytes_to_read = 0;
> }
>
>
> else if (streambuf_.size() == streambuf_.max_size())
> {
> search_position_ = not_found;
> bytes_to_read = 0;
> }
>
>
> else
> {
> if (result.first != end)
> {
>
>
> search_position_ = result.first - begin;
> }
> else
> {
>
> search_position_ = end - begin;
> }
>
> bytes_to_read = read_size_helper(streambuf_, 65536);
> }
> }
>
>
> if (!start && bytes_to_read == 0)
> break;
>
>
> stream_.async_read_some(streambuf_.prepare(bytes_to_read),
> static_cast<read_until_match_op&&>(*this));
> return; default:
> streambuf_.commit(bytes_transferred);
> if (ec || bytes_transferred == 0)
> break;
> }
>
> const boost::system::error_code result_ec =
> (search_position_ == not_found)
> ? error::not_found : ec;
>
> const std::size_t result_n =
> (ec || search_position_ == not_found)
> ? 0 : search_position_;
>
> handler_(result_ec, result_n);
> }
> }
>
>
> AsyncReadStream& stream_;
> boost::asio::basic_streambuf<Allocator>& streambuf_;
> MatchCondition match_condition_;
> int start_;
> std::size_t search_position_;
> ReadHandler handler_;
> };
>
> template <typename AsyncReadStream, typename Allocator,
> typename MatchCondition, typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_until_match_op<AsyncReadStream,
> Allocator, MatchCondition, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename Allocator,
> typename MatchCondition, typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_until_match_op<AsyncReadStream,
> Allocator, MatchCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename Allocator,
> typename MatchCondition, typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_until_match_op<AsyncReadStream,
> Allocator, MatchCondition, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream, typename Allocator,
> typename MatchCondition, typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_until_match_op<AsyncReadStream,
> Allocator, MatchCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream, typename Allocator,
> typename MatchCondition, typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_until_match_op<AsyncReadStream,
> Allocator, MatchCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>template <typename AsyncReadStream, typename Allocator,
> typename MatchCondition, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> MatchCondition match_condition, ReadHandler&& handler,
> typename enable_if<is_match_condition<MatchCondition>::value>::type*)
>{
>
>
> typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> ReadHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<ReadHandler&&>(handler));
>
> detail::read_until_match_op<AsyncReadStream, Allocator,
> MatchCondition, typename handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> s, b, match_condition, init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 1148 "/usr/include/boost/asio/impl/read_until.hpp" 2 3 4
># 922 "/usr/include/boost/asio/read_until.hpp" 2 3 4
># 92 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/serial_port.hpp" 1 3 4
># 26 "/usr/include/boost/asio/serial_port.hpp" 3 4
>namespace boost {
>namespace asio {
>
>
>typedef basic_serial_port<> serial_port;
>
>}
>}
># 94 "/usr/include/boost/asio.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/signal_set.hpp" 1 3 4
># 21 "/usr/include/boost/asio/signal_set.hpp" 3 4
>namespace boost {
>namespace asio {
>
>
>typedef basic_signal_set<> signal_set;
>
>}
>}
># 97 "/usr/include/boost/asio.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/strand.hpp" 1 3 4
># 21 "/usr/include/boost/asio/strand.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/strand_service.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/strand_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/strand_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>class strand_service
> : public boost::asio::detail::service_base<strand_service>
>{
>private:
>
> struct on_do_complete_exit;
>
>
> struct on_dispatch_exit;
>
>public:
>
>
> class strand_impl
> : public operation
> {
> public:
> strand_impl();
>
> private:
>
> friend class strand_service;
> friend struct on_do_complete_exit;
> friend struct on_dispatch_exit;
>
>
> boost::asio::detail::mutex mutex_;
>
>
>
>
> bool locked_;
>
>
>
>
> op_queue<operation> waiting_queue_;
>
>
>
>
> op_queue<operation> ready_queue_;
> };
>
> typedef strand_impl* implementation_type;
>
>
> inline explicit strand_service(boost::asio::io_service& io_service);
>
>
> inline void shutdown_service();
>
>
> inline void construct(implementation_type& impl);
>
>
> template <typename Handler>
> void dispatch(implementation_type& impl, Handler& handler);
>
>
> template <typename Handler>
> void post(implementation_type& impl, Handler& handler);
>
>
> inline bool running_in_this_thread(
> const implementation_type& impl) const;
>
>private:
>
>
> inline bool do_dispatch(implementation_type& impl, operation* op);
>
>
> inline void do_post(implementation_type& impl,
> operation* op, bool is_continuation);
>
> inline static void do_complete(io_service_impl* owner,
> operation* base, const boost::system::error_code& ec,
> std::size_t bytes_transferred);
>
>
> io_service_impl& io_service_;
>
>
> boost::asio::detail::mutex mutex_;
>
>
>
>
>
> enum { num_implementations = 193 };
>
>
>
> scoped_ptr<strand_impl> implementations_[num_implementations];
>
>
>
> std::size_t salt_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 138 "/usr/include/boost/asio/detail/strand_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/strand_service.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/impl/strand_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/impl/strand_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>inline strand_service::strand_impl::strand_impl()
> : operation(&strand_service::do_complete),
> locked_(false)
>{
>}
>
>struct strand_service::on_dispatch_exit
>{
> io_service_impl* io_service_;
> strand_impl* impl_;
>
> ~on_dispatch_exit()
> {
> impl_->mutex_.lock();
> impl_->ready_queue_.push(impl_->waiting_queue_);
> bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty();
> impl_->mutex_.unlock();
>
> if (more_handlers)
> io_service_->post_immediate_completion(impl_, false);
> }
>};
>
>template <typename Handler>
>void strand_service::dispatch(strand_service::implementation_type& impl,
> Handler& handler)
>{
>
> if (call_stack<strand_impl>::contains(impl))
> {
> fenced_block b(fenced_block::full);
> boost_asio_handler_invoke_helpers::invoke(handler, handler);
> return;
> }
>
>
> typedef completion_handler<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0;
>
> bool dispatch_immediately = do_dispatch(impl, p.p);
> operation* o = p.p;
> p.v = p.p = 0;
>
> if (dispatch_immediately)
> {
>
> call_stack<strand_impl>::context ctx(impl);
>
>
> on_dispatch_exit on_exit = { &io_service_, impl };
> (void)on_exit;
>
> completion_handler<Handler>::do_complete(
> &io_service_, o, boost::system::error_code(), 0);
> }
>}
>
>
>template <typename Handler>
>void strand_service::post(strand_service::implementation_type& impl,
> Handler& handler)
>{
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef completion_handler<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> boost_asio_handler_alloc_helpers::allocate(
> sizeof(op), handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0;
>
> do_post(impl, p.p, is_continuation);
> p.v = p.p = 0;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 119 "/usr/include/boost/asio/detail/impl/strand_service.hpp" 2 3 4
># 140 "/usr/include/boost/asio/detail/strand_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/strand_service.ipp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/strand_service.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/strand_service.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/impl/strand_service.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/impl/strand_service.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>struct strand_service::on_do_complete_exit
>{
> io_service_impl* owner_;
> strand_impl* impl_;
>
> ~on_do_complete_exit()
> {
> impl_->mutex_.lock();
> impl_->ready_queue_.push(impl_->waiting_queue_);
> bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty();
> impl_->mutex_.unlock();
>
> if (more_handlers)
> owner_->post_immediate_completion(impl_, true);
> }
>};
>
>strand_service::strand_service(boost::asio::io_service& io_service)
> : boost::asio::detail::service_base<strand_service>(io_service),
> io_service_(boost::asio::use_service<io_service_impl>(io_service)),
> mutex_(),
> salt_(0)
>{
>}
>
>void strand_service::shutdown_service()
>{
> op_queue<operation> ops;
>
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
>
> for (std::size_t i = 0; i < num_implementations; ++i)
> {
> if (strand_impl* impl = implementations_[i].get())
> {
> ops.push(impl->waiting_queue_);
> ops.push(impl->ready_queue_);
> }
> }
>}
>
>void strand_service::construct(strand_service::implementation_type& impl)
>{
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
>
> std::size_t salt = salt_++;
>
>
>
> std::size_t index = reinterpret_cast<std::size_t>(&impl);
> index += (reinterpret_cast<std::size_t>(&impl) >> 3);
> index ^= salt + 0x9e3779b9 + (index << 6) + (index >> 2);
>
> index = index % num_implementations;
>
> if (!implementations_[index].get())
> implementations_[index].reset(new strand_impl);
> impl = implementations_[index].get();
>}
>
>bool strand_service::running_in_this_thread(
> const implementation_type& impl) const
>{
> return call_stack<strand_impl>::contains(impl) != 0;
>}
>
>bool strand_service::do_dispatch(implementation_type& impl, operation* op)
>{
>
>
> bool can_dispatch = io_service_.can_dispatch();
> impl->mutex_.lock();
> if (can_dispatch && !impl->locked_)
> {
>
> impl->locked_ = true;
> impl->mutex_.unlock();
> return true;
> }
>
> if (impl->locked_)
> {
>
> impl->waiting_queue_.push(op);
> impl->mutex_.unlock();
> }
> else
> {
>
>
> impl->locked_ = true;
> impl->mutex_.unlock();
> impl->ready_queue_.push(op);
> io_service_.post_immediate_completion(impl, false);
> }
>
> return false;
>}
>
>void strand_service::do_post(implementation_type& impl,
> operation* op, bool is_continuation)
>{
> impl->mutex_.lock();
> if (impl->locked_)
> {
>
> impl->waiting_queue_.push(op);
> impl->mutex_.unlock();
> }
> else
> {
>
>
> impl->locked_ = true;
> impl->mutex_.unlock();
> impl->ready_queue_.push(op);
> io_service_.post_immediate_completion(impl, is_continuation);
> }
>}
>
>void strand_service::do_complete(io_service_impl* owner, operation* base,
> const boost::system::error_code& ec, std::size_t )
>{
> if (owner)
> {
> strand_impl* impl = static_cast<strand_impl*>(base);
>
>
> call_stack<strand_impl>::context ctx(impl);
>
>
> on_do_complete_exit on_exit = { owner, impl };
> (void)on_exit;
>
>
>
> while (operation* o = impl->ready_queue_.front())
> {
> impl->ready_queue_.pop();
> o->complete(*owner, ec, 0);
> }
> }
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 177 "/usr/include/boost/asio/detail/impl/strand_service.ipp" 2 3 4
># 142 "/usr/include/boost/asio/detail/strand_service.hpp" 2 3 4
># 22 "/usr/include/boost/asio/strand.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/strand.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 83 "/usr/include/boost/asio/strand.hpp" 3 4
>class io_service::strand
>{
>public:
>
>
>
>
>
>
>
> explicit strand(boost::asio::io_service& io_service)
> : service_(boost::asio::use_service<
> boost::asio::detail::strand_service>(io_service))
> {
> service_.construct(impl_);
> }
># 107 "/usr/include/boost/asio/strand.hpp" 3 4
> ~strand()
> {
> }
># 119 "/usr/include/boost/asio/strand.hpp" 3 4
> boost::asio::io_service& get_io_service()
> {
> return service_.get_io_service();
> }
># 143 "/usr/include/boost/asio/strand.hpp" 3 4
> template <typename CompletionHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
> dispatch(CompletionHandler&& handler)
> {
>
>
> typedef typename handler_type<CompletionHandler, void()>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::zero_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), 0)) == 1, "CompletionHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()(), char(0))> type_check;
>
> detail::async_result_init<
> CompletionHandler, void ()> init(
> static_cast<CompletionHandler&&>(handler));
>
> service_.dispatch(impl_, init.handler);
>
> return init.result.get();
> }
># 176 "/usr/include/boost/asio/strand.hpp" 3 4
> template <typename CompletionHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
> post(CompletionHandler&& handler)
> {
>
>
> typedef typename handler_type<CompletionHandler, void()>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::zero_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), 0)) == 1, "CompletionHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()(), char(0))> type_check;
>
> detail::async_result_init<
> CompletionHandler, void ()> init(
> static_cast<CompletionHandler&&>(handler));
>
> service_.post(impl_, init.handler);
>
> return init.result.get();
> }
># 214 "/usr/include/boost/asio/strand.hpp" 3 4
> template <typename Handler>
>
>
>
> detail::wrapped_handler<strand, Handler, detail::is_continuation_if_running>
>
> wrap(Handler handler)
> {
> return detail::wrapped_handler<io_service::strand, Handler,
> detail::is_continuation_if_running>(*this, handler);
> }
>
>
>
>
>
>
>
> bool running_in_this_thread() const
> {
> return service_.running_in_this_thread(impl_);
> }
>
>private:
> boost::asio::detail::strand_service& service_;
> boost::asio::detail::strand_service::implementation_type impl_;
>};
>
>
>typedef boost::asio::io_service::strand strand;
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 249 "/usr/include/boost/asio/strand.hpp" 2 3 4
># 101 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/streambuf.hpp" 1 3 4
># 24 "/usr/include/boost/asio/streambuf.hpp" 3 4
>namespace boost {
>namespace asio {
>
>
>typedef basic_streambuf<> streambuf;
>
>}
>}
># 103 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/version.hpp" 1 3 4
># 105 "/usr/include/boost/asio.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/windows/basic_handle.hpp" 1 3 4
># 108 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/basic_object_handle.hpp" 1 3 4
># 109 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/basic_random_access_handle.hpp" 1 3 4
># 110 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/basic_stream_handle.hpp" 1 3 4
># 111 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/object_handle.hpp" 1 3 4
># 112 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/object_handle_service.hpp" 1 3 4
># 113 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/overlapped_ptr.hpp" 1 3 4
># 114 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/random_access_handle.hpp" 1 3 4
># 115 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/random_access_handle_service.hpp" 1 3 4
># 116 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/stream_handle.hpp" 1 3 4
># 117 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/stream_handle_service.hpp" 1 3 4
># 118 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/write_at.hpp" 1 3 4
># 19 "/usr/include/boost/asio/write_at.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 20 "/usr/include/boost/asio/write_at.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 26 "/usr/include/boost/asio/write_at.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 76 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers);
># 120 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> boost::system::error_code& ec);
># 174 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition);
># 222 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec);
># 259 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename Allocator>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, basic_streambuf<Allocator>& b);
># 292 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename Allocator>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, basic_streambuf<Allocator>& b,
> boost::system::error_code& ec);
># 335 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename Allocator,
> typename CompletionCondition>
>std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
> basic_streambuf<Allocator>& b, CompletionCondition completion_condition);
># 379 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename Allocator,
> typename CompletionCondition>
>std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
> basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
> boost::system::error_code& ec);
># 447 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
> const ConstBufferSequence& buffers,
> WriteHandler&& handler);
># 521 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write_at(AsyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition,
> WriteHandler&& handler);
># 572 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename AsyncRandomAccessWriteDevice, typename Allocator,
> typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
> basic_streambuf<Allocator>& b, WriteHandler&& handler);
># 633 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename AsyncRandomAccessWriteDevice, typename Allocator,
> typename CompletionCondition, typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
> basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
> WriteHandler&& handler);
>
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 649 "/usr/include/boost/asio/write_at.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/write_at.hpp" 1 3 4
># 31 "/usr/include/boost/asio/impl/write_at.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 32 "/usr/include/boost/asio/impl/write_at.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> boost::asio::detail::consuming_buffers<
> const_buffer, ConstBufferSequence> tmp(buffers);
> std::size_t total_transferred = 0;
> tmp.prepare(detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred)));
> while (tmp.begin() != tmp.end())
> {
> std::size_t bytes_transferred = d.write_some_at(
> offset + total_transferred, tmp, ec);
> tmp.consume(bytes_transferred);
> total_transferred += bytes_transferred;
> tmp.prepare(detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred)));
> }
> return total_transferred;
>}
>
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
>inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write_at(
> d, offset, buffers, transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "write_at");
> return bytes_transferred;
>}
>
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
>inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> boost::system::error_code& ec)
>{
> return write_at(d, offset, buffers, transfer_all(), ec);
>}
>
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition>
>inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write_at(
> d, offset, buffers, completion_condition, ec);
> boost::asio::detail::throw_error(ec, "write_at");
> return bytes_transferred;
>}
>
>
>
>template <typename SyncRandomAccessWriteDevice, typename Allocator,
> typename CompletionCondition>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition, boost::system::error_code& ec)
>{
> std::size_t bytes_transferred = write_at(
> d, offset, b.data(), completion_condition, ec);
> b.consume(bytes_transferred);
> return bytes_transferred;
>}
>
>template <typename SyncRandomAccessWriteDevice, typename Allocator>
>inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write_at(d, offset, b, transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "write_at");
> return bytes_transferred;
>}
>
>template <typename SyncRandomAccessWriteDevice, typename Allocator>
>inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> boost::system::error_code& ec)
>{
> return write_at(d, offset, b, transfer_all(), ec);
>}
>
>template <typename SyncRandomAccessWriteDevice, typename Allocator,
> typename CompletionCondition>
>inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write_at(
> d, offset, b, completion_condition, ec);
> boost::asio::detail::throw_error(ec, "write_at");
> return bytes_transferred;
>}
>
>
>
>namespace detail
>{
> template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
> class write_at_op
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> write_at_op(AsyncRandomAccessWriteDevice& device,
> uint64_t offset, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition, WriteHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> device_(device),
> offset_(offset),
> buffers_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_at_op(const write_at_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> write_at_op(write_at_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> switch (start_ = start)
> {
> case 1:
> buffers_.prepare(this->check_for_completion(ec, total_transferred_));
> for (;;)
> {
> device_.async_write_some_at(
> offset_ + total_transferred_, buffers_,
> static_cast<write_at_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> buffers_.consume(bytes_transferred);
> buffers_.prepare(this->check_for_completion(ec, total_transferred_));
> if ((!ec && bytes_transferred == 0)
> || buffers_.begin() == buffers_.end())
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncRandomAccessWriteDevice& device_;
> uint64_t offset_;
> boost::asio::detail::consuming_buffers<
> const_buffer, ConstBufferSequence> buffers_;
> int start_;
> std::size_t total_transferred_;
> WriteHandler handler_;
> };
>
> template <typename AsyncRandomAccessWriteDevice,
> typename CompletionCondition, typename WriteHandler>
> class write_at_op<AsyncRandomAccessWriteDevice,
> boost::asio::mutable_buffers_1, CompletionCondition, WriteHandler>
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> write_at_op(AsyncRandomAccessWriteDevice& device,
> uint64_t offset, const boost::asio::mutable_buffers_1& buffers,
> CompletionCondition completion_condition,
> WriteHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> device_(device),
> offset_(offset),
> buffer_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_at_op(const write_at_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffer_(other.buffer_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> write_at_op(write_at_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffer_(other.buffer_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> std::size_t n = 0;
> switch (start_ = start)
> {
> case 1:
> n = this->check_for_completion(ec, total_transferred_);
> for (;;)
> {
> device_.async_write_some_at(offset_ + total_transferred_,
> boost::asio::buffer(buffer_ + total_transferred_, n),
> static_cast<write_at_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> if ((!ec && bytes_transferred == 0)
> || (n = this->check_for_completion(ec, total_transferred_)) == 0
> || total_transferred_ == boost::asio::buffer_size(buffer_))
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncRandomAccessWriteDevice& device_;
> uint64_t offset_;
> boost::asio::mutable_buffer buffer_;
> int start_;
> std::size_t total_transferred_;
> WriteHandler handler_;
> };
>
> template <typename AsyncRandomAccessWriteDevice,
> typename CompletionCondition, typename WriteHandler>
> class write_at_op<AsyncRandomAccessWriteDevice, boost::asio::const_buffers_1,
> CompletionCondition, WriteHandler>
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> write_at_op(AsyncRandomAccessWriteDevice& device,
> uint64_t offset, const boost::asio::const_buffers_1& buffers,
> CompletionCondition completion_condition,
> WriteHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> device_(device),
> offset_(offset),
> buffer_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_at_op(const write_at_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffer_(other.buffer_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> write_at_op(write_at_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffer_(other.buffer_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> std::size_t n = 0;
> switch (start_ = start)
> {
> case 1:
> n = this->check_for_completion(ec, total_transferred_);
> for (;;)
> {
> device_.async_write_some_at(offset_ + total_transferred_,
> boost::asio::buffer(buffer_ + total_transferred_, n),
> static_cast<write_at_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> if ((!ec && bytes_transferred == 0)
> || (n = this->check_for_completion(ec, total_transferred_)) == 0
> || total_transferred_ == boost::asio::buffer_size(buffer_))
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncRandomAccessWriteDevice& device_;
> uint64_t offset_;
> boost::asio::const_buffer buffer_;
> int start_;
> std::size_t total_transferred_;
> WriteHandler handler_;
> };
>
> template <typename AsyncRandomAccessWriteDevice, typename Elem,
> typename CompletionCondition, typename WriteHandler>
> class write_at_op<AsyncRandomAccessWriteDevice, boost::array<Elem, 2>,
> CompletionCondition, WriteHandler>
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> write_at_op(AsyncRandomAccessWriteDevice& device,
> uint64_t offset, const boost::array<Elem, 2>& buffers,
> CompletionCondition completion_condition, WriteHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> device_(device),
> offset_(offset),
> buffers_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_at_op(const write_at_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> write_at_op(write_at_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> typename boost::asio::detail::dependent_type<Elem,
> boost::array<boost::asio::const_buffer, 2> >::type bufs = {{
> boost::asio::const_buffer(buffers_[0]),
> boost::asio::const_buffer(buffers_[1]) }};
> std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
> std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
> std::size_t n = 0;
> switch (start_ = start)
> {
> case 1:
> n = this->check_for_completion(ec, total_transferred_);
> for (;;)
> {
> bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
> bufs[1] = boost::asio::buffer(
> bufs[1] + (total_transferred_ < buffer_size0
> ? 0 : total_transferred_ - buffer_size0),
> n - boost::asio::buffer_size(bufs[0]));
> device_.async_write_some_at(offset_ + total_transferred_,
> bufs, static_cast<write_at_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> if ((!ec && bytes_transferred == 0)
> || (n = this->check_for_completion(ec, total_transferred_)) == 0
> || total_transferred_ == buffer_size0 + buffer_size1)
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncRandomAccessWriteDevice& device_;
> uint64_t offset_;
> boost::array<Elem, 2> buffers_;
> int start_;
> std::size_t total_transferred_;
> WriteHandler handler_;
> };
>
>
>
> template <typename AsyncRandomAccessWriteDevice, typename Elem,
> typename CompletionCondition, typename WriteHandler>
> class write_at_op<AsyncRandomAccessWriteDevice, std::array<Elem, 2>,
> CompletionCondition, WriteHandler>
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> write_at_op(AsyncRandomAccessWriteDevice& device,
> uint64_t offset, const std::array<Elem, 2>& buffers,
> CompletionCondition completion_condition, WriteHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> device_(device),
> offset_(offset),
> buffers_(buffers),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_at_op(const write_at_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> write_at_op(write_at_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> typename boost::asio::detail::dependent_type<Elem,
> std::array<boost::asio::const_buffer, 2> >::type bufs = {{
> boost::asio::const_buffer(buffers_[0]),
> boost::asio::const_buffer(buffers_[1]) }};
> std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
> std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
> std::size_t n = 0;
> switch (start_ = start)
> {
> case 1:
> n = this->check_for_completion(ec, total_transferred_);
> for (;;)
> {
> bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
> bufs[1] = boost::asio::buffer(
> bufs[1] + (total_transferred_ < buffer_size0
> ? 0 : total_transferred_ - buffer_size0),
> n - boost::asio::buffer_size(bufs[0]));
> device_.async_write_some_at(offset_ + total_transferred_,
> bufs, static_cast<write_at_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> if ((!ec && bytes_transferred == 0)
> || (n = this->check_for_completion(ec, total_transferred_)) == 0
> || total_transferred_ == buffer_size0 + buffer_size1)
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncRandomAccessWriteDevice& device_;
> uint64_t offset_;
> std::array<Elem, 2> buffers_;
> int start_;
> std::size_t total_transferred_;
> WriteHandler handler_;
> };
>
>
>
> template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
> inline void* asio_handler_allocate(std::size_t size,
> write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
> CompletionCondition, WriteHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
> CompletionCondition, WriteHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
> inline bool asio_handler_is_continuation(
> write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
> CompletionCondition, WriteHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncRandomAccessWriteDevice,
> typename ConstBufferSequence, typename CompletionCondition,
> typename WriteHandler>
> inline void asio_handler_invoke(Function& function,
> write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
> CompletionCondition, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncRandomAccessWriteDevice,
> typename ConstBufferSequence, typename CompletionCondition,
> typename WriteHandler>
> inline void asio_handler_invoke(const Function& function,
> write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
> CompletionCondition, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
> inline write_at_op<AsyncRandomAccessWriteDevice,
> ConstBufferSequence, CompletionCondition, WriteHandler>
> make_write_at_op(AsyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition, WriteHandler handler)
> {
> return write_at_op<AsyncRandomAccessWriteDevice,
> ConstBufferSequence, CompletionCondition, WriteHandler>(
> d, offset, buffers, completion_condition, handler);
> }
>}
>
>template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write_at(AsyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition,
> WriteHandler&& handler)
>{
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> WriteHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<WriteHandler&&>(handler));
>
> detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
> CompletionCondition, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> d, offset, buffers, completion_condition, init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write_at(AsyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> WriteHandler&& handler)
>{
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> WriteHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<WriteHandler&&>(handler));
>
> detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
> detail::transfer_all_t, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> d, offset, buffers, transfer_all(), init.handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>
>
>namespace detail
>{
> template <typename Allocator, typename WriteHandler>
> class write_at_streambuf_op
> {
> public:
> write_at_streambuf_op(
> boost::asio::basic_streambuf<Allocator>& streambuf,
> WriteHandler& handler)
> : streambuf_(streambuf),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_at_streambuf_op(const write_at_streambuf_op& other)
> : streambuf_(other.streambuf_),
> handler_(other.handler_)
> {
> }
>
> write_at_streambuf_op(write_at_streambuf_op&& other)
> : streambuf_(other.streambuf_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> const std::size_t bytes_transferred)
> {
> streambuf_.consume(bytes_transferred);
> handler_(ec, bytes_transferred);
> }
>
>
> boost::asio::basic_streambuf<Allocator>& streambuf_;
> WriteHandler handler_;
> };
>
> template <typename Allocator, typename WriteHandler>
> inline void* asio_handler_allocate(std::size_t size,
> write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename Allocator, typename WriteHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename Allocator, typename WriteHandler>
> inline bool asio_handler_is_continuation(
> write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
> {
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename Allocator, typename WriteHandler>
> inline void asio_handler_invoke(Function& function,
> write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename Allocator, typename WriteHandler>
> inline void asio_handler_invoke(const Function& function,
> write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Allocator, typename WriteHandler>
> inline write_at_streambuf_op<Allocator, WriteHandler>
> make_write_at_streambuf_op(
> boost::asio::basic_streambuf<Allocator>& b, WriteHandler handler)
> {
> return write_at_streambuf_op<Allocator, WriteHandler>(b, handler);
> }
>}
>
>template <typename AsyncRandomAccessWriteDevice, typename Allocator,
> typename CompletionCondition, typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write_at(AsyncRandomAccessWriteDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition,
> WriteHandler&& handler)
>{
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> WriteHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<WriteHandler&&>(handler));
>
> async_write_at(d, offset, b.data(), completion_condition,
> detail::write_at_streambuf_op<Allocator, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> b, init.handler));
>
> return init.result.get();
>}
>
>template <typename AsyncRandomAccessWriteDevice, typename Allocator,
> typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
>
>async_write_at(AsyncRandomAccessWriteDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> WriteHandler&& handler)
>{
>
>
> typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> type_check;
>
> detail::async_result_init<
> WriteHandler, void (boost::system::error_code, std::size_t)> init(
> static_cast<WriteHandler&&>(handler));
>
> async_write_at(d, offset, b.data(), transfer_all(),
> detail::write_at_streambuf_op<Allocator, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type
> >(
> b, init.handler));
>
> return init.result.get();
>}
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 826 "/usr/include/boost/asio/impl/write_at.hpp" 2 3 4
># 651 "/usr/include/boost/asio/write_at.hpp" 2 3 4
># 120 "/usr/include/boost/asio.hpp" 2 3 4
># 22 "../src/commands.h" 2
>
>
>
>using boost::asio::ip::tcp;
>
>
>
>namespace iwf
>{
> enum ecommand
> {
> nullCommand = 0,
> acknowledgetarget,
> anulltarget,
> autogain,
> calibrate,
> clearhistory,
> debug,
> demo,
> doprint,
> doscan,
> feedback,
> filter,
> findhorizon,
> forgetoldtargets,
> forgettarget,
> gain,
> getactivetargets,
> getallpoints,
> getalltargets,
> getfilesfromtarget,
> getID,
> getiwcctemp,
> getposition,
> getstatus,
> gettargetdetail,
> horizon,
> ignoretarget,
> loadstate,
> maxaltitude,
> measure,
> minaltitude,
> moverel,
> moveto,
> nofirmwarecheck,
> nostore,
> pauseexec,
> picture,
> ping,
> power,
> psu,
> ratio,
> readfirmware,
> repeats,
> reset,
> restart,
> restoretarget,
> resume,
> savestate,
> scanstart,
> scanstop,
> setcaptureparams,
> setcurrents,
> setdate,
> setdistancecorrectionparameters,
> setdistancelimits,
> setpassword,
> setpoints,
> setposition,
> setsensorposition,
> shutdown,
> stepsize,
> storedata,
> stop,
> test,
> updatefirmware,
> };
>
>
>
> enum eparamType
> {
> noneT,
> intT,
> stringT,
> boolT,
> realT,
> realArrayT
> };
>
> const double defMinVal = -65535;
> const double defMaxVal = 65535;
> const uint32_t maxArraySize = 2046;
>
>
>
>
>
>
>
> class paramVal
> {
>
>
>
> public:
> paramVal(eparamType t, double mi = defMinVal, double ma = defMaxVal, bool nz = false)
> :type(t), min(mi), max(ma), nozeroes(nz), hasValue(false), isSpecial(false) {};
> ~paramVal(void) {clearValue();};
>
> paramVal &operator =(const int i) {clearValue();hasValue = true; ival = i; type = intT; return *this;};
> paramVal &operator =(const bool b) {clearValue();hasValue = true; bval = b; type = boolT; return *this;};
> paramVal &operator =(const double d) {clearValue();hasValue = true; rval = d; type = realT; return *this;};
> paramVal &operator =(const char *s);
> paramVal &operator +=(const char *s);
> paramVal &operator =(const std::string &s);
> paramVal &operator =(std::vector<double> *ra) {clearValue();hasValue = true; rarrayval = ra; type = realArrayT; return *this;};
>
> bool boolean() {if (hasValue and type == boolT) return bval; else throw error(wrongType);};
> int integer() {if (hasValue and type == intT) return ival; else throw error(wrongType);};
> double real() {if (hasValue and type == realT) return rval; else throw error(wrongType);};
> std::string *string() {if (hasValue and type == stringT) return sval; else throw error(wrongType);};
> std::vector<double> *realArray(){if (hasValue and type == realArrayT) return rarrayval; else throw error(wrongType);};
> uint32_t arraySize();
>
> eparamType type;
> double min;
> double max;
> bool nozeroes;
> bool hasValue;
> bool isSpecial;
>
> friend std::ostream & operator << (std::ostream &, paramVal &);
>
> private:
>
>
>
> union
> {
> int ival;
> std::string *sval;
> bool bval;
> double rval;
> std::vector<double> *rarrayval;
> };
>
> void clearValue(void);
> };
>
> const paramVal intParam(intT);
> const paramVal boolParam(boolT, 0, 1);
> const paramVal realParam(realT);
> const paramVal stringParam(stringT);
>
>
>
> std::ostream & operator << (std::ostream &out, paramVal &param);
>
>
>
> inline bool isSpecial(double d, int &val)
> {
> if (!std::isfinite(d))
> {
> uint8_t *bytes = (uint8_t *)(&d);
> val = bytes[7];
> return true;
> }
> return false;
> };
>
>
>
>
>
> struct conditions
> {
> conditions(bool s = false, bool p = false, bool sp = false, bool h = false, bool hd = false)
> :stopped(s), paused(p), stoppedOrPaused(sp), horizon(h), havedata(hd){};
>
> bool stopped : 1;
> bool paused : 1;
> bool stoppedOrPaused : 1;
> bool horizon : 1;
> bool havedata : 1;
> };
>
> const conditions noCond = conditions();
> const conditions spCond = conditions(false, false, true);
> const conditions sCond = conditions(true);
> const conditions dCond = conditions(false, false, false, false, true);
>
> class command;
> typedef bool (*pfptr)(command &, wildfireStatus &, measurementSettings &, std::stringstream &);
>
>
>
>
>
>
> class command
> {
> public:
>
>
>
> command(pfptr pf,ecommand c, uint32_t minp, uint32_t maxp, const tchar *minn, const tchar *maxn, conditions pc, paramVal p1, paramVal p2, bool cline):
> what(c), minParamCount(minp), maxParamCount(maxp), paramCount(0), minName(minn), fullName(maxn), preConditions(pc), commandLine(cline)
> {
> if (maxp > 0)
> {
> params.push_back(p1);
> }
> if (maxp > 1)
> {
> params.push_back(p2);
> }
> processFunction = pf;
> }
> ecommand what;
> uint32_t minParamCount, maxParamCount, paramCount;
> std::vector<paramVal> params;
> const tchar *minName, *fullName;
> conditions preConditions;
> bool commandLine;
> bool (*processFunction)(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>
> void addParam(paramVal p)
> {
> params.push_back(p);
> }
> };
>
> extern const char * defDumpFilename;
> extern const char * defDataFilename;
>
>
>
>
>
> class commandInfo
> {
> public:
> commandInfo(void);
>
> std::vector<command> commands;
> };
>
> typedef std::list<command *> commandList;
> extern const commandInfo theCommands;
>}
>
>
>uint32_t tokenizeCommand(const std::string &commandString, const tchar **&argv );
>tchar *lowerString(tchar *result, const tchar *input);
>bool comparePartialName(const tchar *inTestString, const tchar *inMinName, const tchar *inName);
>double parseArgumentValue(uint32_t &count, int argc, const tchar **argv, double min, double max, bool &special, bool noZeroes = false, bool optional = false);
>iwf::commandList *parseCommandLine(int argc, const tchar **argv);
>iwf::commandList *parseCommands(int argc, const tchar **argv, bool isCommandLine = false);
>void processCommands(std::basic_ostream<char> **stream, wildfireStatus &stat, measurementSettings &settings, iwf::commandList *theCommands);
>
>
>const double minVertStep = 0.1;
>
>bool findHorizon(measurementSettings &settings, pointData &pdat, double minAltitude, double maxAltitude);
>bool doFindHorizon(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doHorizon(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>
>bool doClearHistory(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doAcknowledgeAllAlarms(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doAcknowledgeOneAlarm(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doAcknowledgeTarget(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doAlarm(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doAnnulTarget(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doAutoGain(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doCalibrate(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doClearHistory(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doDebug(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doDemo(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doFeedback(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doFilter(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doForgetTarget(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doForgetOldTargets(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doGain(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doGetActiveTargets(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doGetAllTargets(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doGetFilesFromTarget(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doGetID(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doGetIWCCtemperature(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doGetPointData(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doGetPoints(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doGetPosition(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doGetTargetDetail(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doIgnoreTarget(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doLoadState(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doMaxAltitude(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doMaxRepeats(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doMeasure(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doMinAltitude(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doMoveRel(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doMoveTo(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doNoFirmwareCheck(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doNoStore(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doPause(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doPicture(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doPing(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doPlot(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doPower(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doPrint(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doPSUStatus(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doRatio(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doReadFirmware(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doRepeats(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doReset(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doRestart(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doRestoreTarget(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doResume(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doSaveState(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doScan(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doScanStart(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doScanStop(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doSetCaptureParams(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doSetDate(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doSetDistanceCorrectionParameters(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doSetDistanceLimits(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doSetMotorCurrentLimits(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doSetPassword(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doSetPoints(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doSetPosition(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doSetSensorPositions(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doShutdown(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doStatus(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doStepSize(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doStop(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doStore(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doTest(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doUnmoving(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
>bool doUpdate(command &theCommand, wildfireStatus &stats, measurementSettings &settings, std::stringstream &result);
># 20 "../src/wildfire.cpp" 2
># 1 "../src/io.h" 1
># 18 "../src/io.h"
># 1 "../src/target.h" 1
># 20 "../src/target.h"
># 1 "../src/file.h" 1
># 16 "../src/file.h"
># 1 "/usr/include/boost/filesystem.hpp" 1 3 4
># 15 "/usr/include/boost/filesystem.hpp" 3 4
># 1 "/usr/include/boost/filesystem/config.hpp" 1 3 4
># 106 "/usr/include/boost/filesystem/config.hpp" 3 4
># 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
># 107 "/usr/include/boost/filesystem/config.hpp" 2 3 4
># 16 "/usr/include/boost/filesystem.hpp" 2 3 4
># 1 "/usr/include/boost/filesystem/path.hpp" 1 3 4
># 25 "/usr/include/boost/filesystem/path.hpp" 3 4
># 1 "/usr/include/boost/filesystem/path_traits.hpp" 1 3 4
># 24 "/usr/include/boost/filesystem/path_traits.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cwchar" 1 3 4
># 39 "/usr/include/c++/4.8.2/cwchar" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cwchar" 3
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 45 "/usr/include/c++/4.8.2/cwchar" 2 3
># 25 "/usr/include/boost/filesystem/path_traits.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/c++/4.8.2/locale" 1 3 4
># 36 "/usr/include/c++/4.8.2/locale" 3 4
> 
># 37 "/usr/include/c++/4.8.2/locale" 3
>
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 1 3
># 37 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> 
># 38 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
>
># 1 "/usr/include/c++/4.8.2/ctime" 1 3
># 39 "/usr/include/c++/4.8.2/ctime" 3
> 
># 40 "/usr/include/c++/4.8.2/ctime" 3
># 40 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 52 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> class time_base
> {
> public:
> enum dateorder { no_order, dmy, mdy, ymd, ydm };
> };
>
> template<typename _CharT>
> struct __timepunct_cache : public locale::facet
> {
>
> static const _CharT* _S_timezones[14];
>
> const _CharT* _M_date_format;
> const _CharT* _M_date_era_format;
> const _CharT* _M_time_format;
> const _CharT* _M_time_era_format;
> const _CharT* _M_date_time_format;
> const _CharT* _M_date_time_era_format;
> const _CharT* _M_am;
> const _CharT* _M_pm;
> const _CharT* _M_am_pm_format;
>
>
> const _CharT* _M_day1;
> const _CharT* _M_day2;
> const _CharT* _M_day3;
> const _CharT* _M_day4;
> const _CharT* _M_day5;
> const _CharT* _M_day6;
> const _CharT* _M_day7;
>
>
> const _CharT* _M_aday1;
> const _CharT* _M_aday2;
> const _CharT* _M_aday3;
> const _CharT* _M_aday4;
> const _CharT* _M_aday5;
> const _CharT* _M_aday6;
> const _CharT* _M_aday7;
>
>
> const _CharT* _M_month01;
> const _CharT* _M_month02;
> const _CharT* _M_month03;
> const _CharT* _M_month04;
> const _CharT* _M_month05;
> const _CharT* _M_month06;
> const _CharT* _M_month07;
> const _CharT* _M_month08;
> const _CharT* _M_month09;
> const _CharT* _M_month10;
> const _CharT* _M_month11;
> const _CharT* _M_month12;
>
>
> const _CharT* _M_amonth01;
> const _CharT* _M_amonth02;
> const _CharT* _M_amonth03;
> const _CharT* _M_amonth04;
> const _CharT* _M_amonth05;
> const _CharT* _M_amonth06;
> const _CharT* _M_amonth07;
> const _CharT* _M_amonth08;
> const _CharT* _M_amonth09;
> const _CharT* _M_amonth10;
> const _CharT* _M_amonth11;
> const _CharT* _M_amonth12;
>
> bool _M_allocated;
>
> __timepunct_cache(size_t __refs = 0) : facet(__refs),
> _M_date_format(0), _M_date_era_format(0), _M_time_format(0),
> _M_time_era_format(0), _M_date_time_format(0),
> _M_date_time_era_format(0), _M_am(0), _M_pm(0),
> _M_am_pm_format(0), _M_day1(0), _M_day2(0), _M_day3(0),
> _M_day4(0), _M_day5(0), _M_day6(0), _M_day7(0),
> _M_aday1(0), _M_aday2(0), _M_aday3(0), _M_aday4(0),
> _M_aday5(0), _M_aday6(0), _M_aday7(0), _M_month01(0),
> _M_month02(0), _M_month03(0), _M_month04(0), _M_month05(0),
> _M_month06(0), _M_month07(0), _M_month08(0), _M_month09(0),
> _M_month10(0), _M_month11(0), _M_month12(0), _M_amonth01(0),
> _M_amonth02(0), _M_amonth03(0), _M_amonth04(0),
> _M_amonth05(0), _M_amonth06(0), _M_amonth07(0),
> _M_amonth08(0), _M_amonth09(0), _M_amonth10(0),
> _M_amonth11(0), _M_amonth12(0), _M_allocated(false)
> { }
>
> ~__timepunct_cache();
>
> void
> _M_cache(const locale& __loc);
>
> private:
> __timepunct_cache&
> operator=(const __timepunct_cache&);
>
> explicit
> __timepunct_cache(const __timepunct_cache&);
> };
>
> template<typename _CharT>
> __timepunct_cache<_CharT>::~__timepunct_cache()
> {
> if (_M_allocated)
> {
>
> }
> }
>
>
> template<>
> const char*
> __timepunct_cache<char>::_S_timezones[14];
>
>
> template<>
> const wchar_t*
> __timepunct_cache<wchar_t>::_S_timezones[14];
>
>
>
> template<typename _CharT>
> const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];
>
> template<typename _CharT>
> class __timepunct : public locale::facet
> {
> public:
>
> typedef _CharT __char_type;
> typedef basic_string<_CharT> __string_type;
> typedef __timepunct_cache<_CharT> __cache_type;
>
> protected:
> __cache_type* _M_data;
> __c_locale _M_c_locale_timepunct;
> const char* _M_name_timepunct;
>
> public:
>
> static locale::id id;
>
> explicit
> __timepunct(size_t __refs = 0);
>
> explicit
> __timepunct(__cache_type* __cache, size_t __refs = 0);
># 210 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> explicit
> __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);
>
>
>
> void
> _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
> const tm* __tm) const throw ();
>
> void
> _M_date_formats(const _CharT** __date) const
> {
>
> __date[0] = _M_data->_M_date_format;
> __date[1] = _M_data->_M_date_era_format;
> }
>
> void
> _M_time_formats(const _CharT** __time) const
> {
>
> __time[0] = _M_data->_M_time_format;
> __time[1] = _M_data->_M_time_era_format;
> }
>
> void
> _M_date_time_formats(const _CharT** __dt) const
> {
>
> __dt[0] = _M_data->_M_date_time_format;
> __dt[1] = _M_data->_M_date_time_era_format;
> }
>
> void
> _M_am_pm_format(const _CharT* __ampm) const
> { __ampm = _M_data->_M_am_pm_format; }
>
> void
> _M_am_pm(const _CharT** __ampm) const
> {
> __ampm[0] = _M_data->_M_am;
> __ampm[1] = _M_data->_M_pm;
> }
>
> void
> _M_days(const _CharT** __days) const
> {
> __days[0] = _M_data->_M_day1;
> __days[1] = _M_data->_M_day2;
> __days[2] = _M_data->_M_day3;
> __days[3] = _M_data->_M_day4;
> __days[4] = _M_data->_M_day5;
> __days[5] = _M_data->_M_day6;
> __days[6] = _M_data->_M_day7;
> }
>
> void
> _M_days_abbreviated(const _CharT** __days) const
> {
> __days[0] = _M_data->_M_aday1;
> __days[1] = _M_data->_M_aday2;
> __days[2] = _M_data->_M_aday3;
> __days[3] = _M_data->_M_aday4;
> __days[4] = _M_data->_M_aday5;
> __days[5] = _M_data->_M_aday6;
> __days[6] = _M_data->_M_aday7;
> }
>
> void
> _M_months(const _CharT** __months) const
> {
> __months[0] = _M_data->_M_month01;
> __months[1] = _M_data->_M_month02;
> __months[2] = _M_data->_M_month03;
> __months[3] = _M_data->_M_month04;
> __months[4] = _M_data->_M_month05;
> __months[5] = _M_data->_M_month06;
> __months[6] = _M_data->_M_month07;
> __months[7] = _M_data->_M_month08;
> __months[8] = _M_data->_M_month09;
> __months[9] = _M_data->_M_month10;
> __months[10] = _M_data->_M_month11;
> __months[11] = _M_data->_M_month12;
> }
>
> void
> _M_months_abbreviated(const _CharT** __months) const
> {
> __months[0] = _M_data->_M_amonth01;
> __months[1] = _M_data->_M_amonth02;
> __months[2] = _M_data->_M_amonth03;
> __months[3] = _M_data->_M_amonth04;
> __months[4] = _M_data->_M_amonth05;
> __months[5] = _M_data->_M_amonth06;
> __months[6] = _M_data->_M_amonth07;
> __months[7] = _M_data->_M_amonth08;
> __months[8] = _M_data->_M_amonth09;
> __months[9] = _M_data->_M_amonth10;
> __months[10] = _M_data->_M_amonth11;
> __months[11] = _M_data->_M_amonth12;
> }
>
> protected:
> virtual
> ~__timepunct();
>
>
> void
> _M_initialize_timepunct(__c_locale __cloc = 0);
> };
>
> template<typename _CharT>
> locale::id __timepunct<_CharT>::id;
>
>
> template<>
> void
> __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);
>
> template<>
> void
> __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const throw ();
>
>
> template<>
> void
> __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);
>
> template<>
> void
> __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
> const tm*) const throw ();
>
>
>
>}
>
>
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/time_members.h" 1 3
># 37 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/time_members.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT>
> __timepunct<_CharT>::__timepunct(size_t __refs)
> : facet(__refs), _M_data(0), _M_c_locale_timepunct(0),
> _M_name_timepunct(_S_get_c_name())
> { _M_initialize_timepunct(); }
>
> template<typename _CharT>
> __timepunct<_CharT>::__timepunct(__cache_type* __cache, size_t __refs)
> : facet(__refs), _M_data(__cache), _M_c_locale_timepunct(0),
> _M_name_timepunct(_S_get_c_name())
> { _M_initialize_timepunct(); }
>
> template<typename _CharT>
> __timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s,
> size_t __refs)
> : facet(__refs), _M_data(0), _M_c_locale_timepunct(0),
> _M_name_timepunct(0)
> {
> if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
> {
> const size_t __len = __builtin_strlen(__s) + 1;
> char* __tmp = new char[__len];
> __builtin_memcpy(__tmp, __s, __len);
> _M_name_timepunct = __tmp;
> }
> else
> _M_name_timepunct = _S_get_c_name();
>
> try
> { _M_initialize_timepunct(__cloc); }
> catch(...)
> {
> if (_M_name_timepunct != _S_get_c_name())
> delete [] _M_name_timepunct;
> throw;
> }
> }
>
> template<typename _CharT>
> __timepunct<_CharT>::~__timepunct()
> {
> if (_M_name_timepunct != _S_get_c_name())
> delete [] _M_name_timepunct;
> delete _M_data;
> _S_destroy_c_locale(_M_c_locale_timepunct);
> }
>
>
>}
># 349 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 367 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> template<typename _CharT, typename _InIter>
> class time_get : public locale::facet, public time_base
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _InIter iter_type;
>
> typedef basic_string<_CharT> __string_type;
>
>
> static locale::id id;
># 389 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> explicit
> time_get(size_t __refs = 0)
> : facet (__refs) { }
># 406 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> dateorder
> date_order() const
> { return this->do_date_order(); }
># 430 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> iter_type
> get_time(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> { return this->do_get_time(__beg, __end, __io, __err, __tm); }
># 455 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> iter_type
> get_date(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> { return this->do_get_date(__beg, __end, __io, __err, __tm); }
># 483 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> iter_type
> get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
># 512 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> iter_type
> get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
># 538 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> iter_type
> get_year(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> { return this->do_get_year(__beg, __end, __io, __err, __tm); }
>
> protected:
>
> virtual
> ~time_get() { }
># 558 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual dateorder
> do_date_order() const;
># 576 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual iter_type
> do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const;
># 595 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual iter_type
> do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const;
># 614 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual iter_type
> do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
> ios_base::iostate& __err, tm* __tm) const;
># 633 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual iter_type
> do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
> ios_base::iostate& __err, tm* __tm) const;
># 652 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual iter_type
> do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const;
>
>
> iter_type
> _M_extract_num(iter_type __beg, iter_type __end, int& __member,
> int __min, int __max, size_t __len,
> ios_base& __io, ios_base::iostate& __err) const;
>
>
> iter_type
> _M_extract_name(iter_type __beg, iter_type __end, int& __member,
> const _CharT** __names, size_t __indexlen,
> ios_base& __io, ios_base::iostate& __err) const;
>
>
> iter_type
> _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
> const _CharT** __names, size_t __indexlen,
> ios_base& __io, ios_base::iostate& __err) const;
>
>
> iter_type
> _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm,
> const _CharT* __format) const;
> };
>
> template<typename _CharT, typename _InIter>
> locale::id time_get<_CharT, _InIter>::id;
>
>
> template<typename _CharT, typename _InIter>
> class time_get_byname : public time_get<_CharT, _InIter>
> {
> public:
>
> typedef _CharT char_type;
> typedef _InIter iter_type;
>
> explicit
> time_get_byname(const char*, size_t __refs = 0)
> : time_get<_CharT, _InIter>(__refs) { }
>
> protected:
> virtual
> ~time_get_byname() { }
> };
># 714 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> template<typename _CharT, typename _OutIter>
> class time_put : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _OutIter iter_type;
>
>
>
> static locale::id id;
># 735 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> explicit
> time_put(size_t __refs = 0)
> : facet(__refs) { }
># 754 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
> const _CharT* __beg, const _CharT* __end) const;
># 774 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill,
> const tm* __tm, char __format, char __mod = 0) const
> { return this->do_put(__s, __io, __fill, __tm, __format, __mod); }
>
> protected:
>
> virtual
> ~time_put()
> { }
># 801 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
> char __format, char __mod) const;
> };
>
> template<typename _CharT, typename _OutIter>
> locale::id time_put<_CharT, _OutIter>::id;
>
>
> template<typename _CharT, typename _OutIter>
> class time_put_byname : public time_put<_CharT, _OutIter>
> {
> public:
>
> typedef _CharT char_type;
> typedef _OutIter iter_type;
>
> explicit
> time_put_byname(const char*, size_t __refs = 0)
> : time_put<_CharT, _OutIter>(__refs)
> { };
>
> protected:
> virtual
> ~time_put_byname() { }
> };
># 840 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> class money_base
> {
> public:
> enum part { none, space, symbol, sign, value };
> struct pattern { char field[4]; };
>
> static const pattern _S_default_pattern;
>
> enum
> {
> _S_minus,
> _S_zero,
> _S_end = 11
> };
>
>
>
> static const char* _S_atoms;
>
>
>
> __attribute__ ((__const__)) static pattern
> _S_construct_pattern(char __precedes, char __space, char __posn) throw ();
> };
>
> template<typename _CharT, bool _Intl>
> struct __moneypunct_cache : public locale::facet
> {
> const char* _M_grouping;
> size_t _M_grouping_size;
> bool _M_use_grouping;
> _CharT _M_decimal_point;
> _CharT _M_thousands_sep;
> const _CharT* _M_curr_symbol;
> size_t _M_curr_symbol_size;
> const _CharT* _M_positive_sign;
> size_t _M_positive_sign_size;
> const _CharT* _M_negative_sign;
> size_t _M_negative_sign_size;
> int _M_frac_digits;
> money_base::pattern _M_pos_format;
> money_base::pattern _M_neg_format;
>
>
>
>
> _CharT _M_atoms[money_base::_S_end];
>
> bool _M_allocated;
>
> __moneypunct_cache(size_t __refs = 0) : facet(__refs),
> _M_grouping(0), _M_grouping_size(0), _M_use_grouping(false),
> _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
> _M_curr_symbol(0), _M_curr_symbol_size(0),
> _M_positive_sign(0), _M_positive_sign_size(0),
> _M_negative_sign(0), _M_negative_sign_size(0),
> _M_frac_digits(0),
> _M_pos_format(money_base::pattern()),
> _M_neg_format(money_base::pattern()), _M_allocated(false)
> { }
>
> ~__moneypunct_cache();
>
> void
> _M_cache(const locale& __loc);
>
> private:
> __moneypunct_cache&
> operator=(const __moneypunct_cache&);
>
> explicit
> __moneypunct_cache(const __moneypunct_cache&);
> };
>
> template<typename _CharT, bool _Intl>
> __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
> {
> if (_M_allocated)
> {
> delete [] _M_grouping;
> delete [] _M_curr_symbol;
> delete [] _M_positive_sign;
> delete [] _M_negative_sign;
> }
> }
># 933 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> template<typename _CharT, bool _Intl>
> class moneypunct : public locale::facet, public money_base
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
> typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
>
> private:
> __cache_type* _M_data;
>
> public:
>
>
> static const bool intl = _Intl;
>
> static locale::id id;
># 962 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> explicit
> moneypunct(size_t __refs = 0)
> : facet(__refs), _M_data(0)
> { _M_initialize_moneypunct(); }
># 975 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> explicit
> moneypunct(__cache_type* __cache, size_t __refs = 0)
> : facet(__refs), _M_data(__cache)
> { _M_initialize_moneypunct(); }
># 990 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> explicit
> moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
> : facet(__refs), _M_data(0)
> { _M_initialize_moneypunct(__cloc, __s); }
># 1004 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> char_type
> decimal_point() const
> { return this->do_decimal_point(); }
># 1017 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> char_type
> thousands_sep() const
> { return this->do_thousands_sep(); }
># 1047 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> string
> grouping() const
> { return this->do_grouping(); }
># 1060 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> string_type
> curr_symbol() const
> { return this->do_curr_symbol(); }
># 1077 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> string_type
> positive_sign() const
> { return this->do_positive_sign(); }
># 1094 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> string_type
> negative_sign() const
> { return this->do_negative_sign(); }
># 1110 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> int
> frac_digits() const
> { return this->do_frac_digits(); }
># 1146 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> pattern
> pos_format() const
> { return this->do_pos_format(); }
>
> pattern
> neg_format() const
> { return this->do_neg_format(); }
>
>
> protected:
>
> virtual
> ~moneypunct();
># 1168 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual char_type
> do_decimal_point() const
> { return _M_data->_M_decimal_point; }
># 1180 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual char_type
> do_thousands_sep() const
> { return _M_data->_M_thousands_sep; }
># 1193 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual string
> do_grouping() const
> { return _M_data->_M_grouping; }
># 1206 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual string_type
> do_curr_symbol() const
> { return _M_data->_M_curr_symbol; }
># 1219 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual string_type
> do_positive_sign() const
> { return _M_data->_M_positive_sign; }
># 1232 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual string_type
> do_negative_sign() const
> { return _M_data->_M_negative_sign; }
># 1246 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual int
> do_frac_digits() const
> { return _M_data->_M_frac_digits; }
># 1260 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual pattern
> do_pos_format() const
> { return _M_data->_M_pos_format; }
># 1274 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual pattern
> do_neg_format() const
> { return _M_data->_M_neg_format; }
>
>
> void
> _M_initialize_moneypunct(__c_locale __cloc = 0,
> const char* __name = 0);
> };
>
> template<typename _CharT, bool _Intl>
> locale::id moneypunct<_CharT, _Intl>::id;
>
> template<typename _CharT, bool _Intl>
> const bool moneypunct<_CharT, _Intl>::intl;
>
> template<>
> moneypunct<char, true>::~moneypunct();
>
> template<>
> moneypunct<char, false>::~moneypunct();
>
> template<>
> void
> moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);
>
> template<>
> void
> moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);
>
>
> template<>
> moneypunct<wchar_t, true>::~moneypunct();
>
> template<>
> moneypunct<wchar_t, false>::~moneypunct();
>
> template<>
> void
> moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
> const char*);
>
> template<>
> void
> moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
> const char*);
>
>
>
> template<typename _CharT, bool _Intl>
> class moneypunct_byname : public moneypunct<_CharT, _Intl>
> {
> public:
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
> static const bool intl = _Intl;
>
> explicit
> moneypunct_byname(const char* __s, size_t __refs = 0)
> : moneypunct<_CharT, _Intl>(__refs)
> {
> if (__builtin_strcmp(__s, "C") != 0
> && __builtin_strcmp(__s, "POSIX") != 0)
> {
> __c_locale __tmp;
> this->_S_create_c_locale(__tmp, __s);
> this->_M_initialize_moneypunct(__tmp);
> this->_S_destroy_c_locale(__tmp);
> }
> }
>
> protected:
> virtual
> ~moneypunct_byname() { }
> };
>
> template<typename _CharT, bool _Intl>
> const bool moneypunct_byname<_CharT, _Intl>::intl;
>
>
># 1369 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> template<typename _CharT, typename _InIter>
> class money_get : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _InIter iter_type;
> typedef basic_string<_CharT> string_type;
>
>
>
> static locale::id id;
># 1391 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> explicit
> money_get(size_t __refs = 0) : facet(__refs) { }
># 1421 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> iter_type
> get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, long double& __units) const
> { return this->do_get(__s, __end, __intl, __io, __err, __units); }
># 1452 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> iter_type
> get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, string_type& __digits) const
> { return this->do_get(__s, __end, __intl, __io, __err, __digits); }
>
> protected:
>
> virtual
> ~money_get() { }
># 1475 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual iter_type
> do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, long double& __units) const;
># 1487 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual iter_type
> do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, string_type& __digits) const;
># 1498 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> template<bool _Intl>
> iter_type
> _M_extract(iter_type __s, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, string& __digits) const;
> };
>
> template<typename _CharT, typename _InIter>
> locale::id money_get<_CharT, _InIter>::id;
># 1520 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> template<typename _CharT, typename _OutIter>
> class money_put : public locale::facet
> {
> public:
>
>
> typedef _CharT char_type;
> typedef _OutIter iter_type;
> typedef basic_string<_CharT> string_type;
>
>
>
> static locale::id id;
># 1541 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> explicit
> money_put(size_t __refs = 0) : facet(__refs) { }
># 1561 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> iter_type
> put(iter_type __s, bool __intl, ios_base& __io,
> char_type __fill, long double __units) const
> { return this->do_put(__s, __intl, __io, __fill, __units); }
># 1584 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> iter_type
> put(iter_type __s, bool __intl, ios_base& __io,
> char_type __fill, const string_type& __digits) const
> { return this->do_put(__s, __intl, __io, __fill, __digits); }
>
> protected:
>
> virtual
> ~money_put() { }
># 1618 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual iter_type
> do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
> long double __units) const;
># 1642 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual iter_type
> do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
> const string_type& __digits) const;
># 1653 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> template<bool _Intl>
> iter_type
> _M_insert(iter_type __s, ios_base& __io, char_type __fill,
> const string_type& __digits) const;
> };
>
> template<typename _CharT, typename _OutIter>
> locale::id money_put<_CharT, _OutIter>::id;
>
>
>
>
>
>
>
> struct messages_base
> {
> typedef int catalog;
> };
># 1694 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> template<typename _CharT>
> class messages : public locale::facet, public messages_base
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
>
> protected:
>
>
> __c_locale _M_c_locale_messages;
> const char* _M_name_messages;
>
> public:
>
> static locale::id id;
># 1722 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> explicit
> messages(size_t __refs = 0);
># 1736 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> explicit
> messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
># 1749 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> catalog
> open(const basic_string<char>& __s, const locale& __loc) const
> { return this->do_open(__s, __loc); }
># 1767 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> catalog
> open(const basic_string<char>&, const locale&, const char*) const;
># 1785 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> string_type
> get(catalog __c, int __set, int __msgid, const string_type& __s) const
> { return this->do_get(__c, __set, __msgid, __s); }
># 1796 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> void
> close(catalog __c) const
> { return this->do_close(__c); }
>
> protected:
>
> virtual
> ~messages();
># 1816 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual catalog
> do_open(const basic_string<char>&, const locale&) const;
># 1835 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 3
> virtual string_type
> do_get(catalog, int, int, const string_type& __dfault) const;
>
>
>
>
>
>
> virtual void
> do_close(catalog) const;
>
>
> char*
> _M_convert_to_char(const string_type& __msg) const
> {
>
> return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
> }
>
>
> string_type
> _M_convert_from_char(char*) const
> {
>
> return string_type();
> }
> };
>
> template<typename _CharT>
> locale::id messages<_CharT>::id;
>
>
> template<>
> string
> messages<char>::do_get(catalog, int, int, const string&) const;
>
>
> template<>
> wstring
> messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;
>
>
>
> template<typename _CharT>
> class messages_byname : public messages<_CharT>
> {
> public:
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
> explicit
> messages_byname(const char* __s, size_t __refs = 0);
>
> protected:
> virtual
> ~messages_byname()
> { }
> };
>
>
>}
>
>
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/messages_members.h" 1 3
># 36 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/messages_members.h" 3
># 1 "/usr/include/libintl.h" 1 3 4
># 34 "/usr/include/libintl.h" 3 4
>extern "C" {
>
>
>
>
>extern char *gettext (const char *__msgid)
> throw () __attribute__ ((__format_arg__ (1)));
>
>
>
>extern char *dgettext (const char *__domainname, const char *__msgid)
> throw () __attribute__ ((__format_arg__ (2)));
>extern char *__dgettext (const char *__domainname, const char *__msgid)
> throw () __attribute__ ((__format_arg__ (2)));
>
>
>
>extern char *dcgettext (const char *__domainname,
> const char *__msgid, int __category)
> throw () __attribute__ ((__format_arg__ (2)));
>extern char *__dcgettext (const char *__domainname,
> const char *__msgid, int __category)
> throw () __attribute__ ((__format_arg__ (2)));
>
>
>
>
>extern char *ngettext (const char *__msgid1, const char *__msgid2,
> unsigned long int __n)
> throw () __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));
>
>
>
>extern char *dngettext (const char *__domainname, const char *__msgid1,
> const char *__msgid2, unsigned long int __n)
> throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
>
>
>
>extern char *dcngettext (const char *__domainname, const char *__msgid1,
> const char *__msgid2, unsigned long int __n,
> int __category)
> throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
>
>
>
>
>
>extern char *textdomain (const char *__domainname) throw ();
>
>
>
>extern char *bindtextdomain (const char *__domainname,
> const char *__dirname) throw ();
>
>
>
>extern char *bind_textdomain_codeset (const char *__domainname,
> const char *__codeset) throw ();
># 121 "/usr/include/libintl.h" 3 4
>}
># 37 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/messages_members.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _CharT>
> messages<_CharT>::messages(size_t __refs)
> : facet(__refs), _M_c_locale_messages(_S_get_c_locale()),
> _M_name_messages(_S_get_c_name())
> { }
>
> template<typename _CharT>
> messages<_CharT>::messages(__c_locale __cloc, const char* __s,
> size_t __refs)
> : facet(__refs), _M_c_locale_messages(0), _M_name_messages(0)
> {
> if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
> {
> const size_t __len = __builtin_strlen(__s) + 1;
> char* __tmp = new char[__len];
> __builtin_memcpy(__tmp, __s, __len);
> _M_name_messages = __tmp;
> }
> else
> _M_name_messages = _S_get_c_name();
>
>
> _M_c_locale_messages = _S_clone_c_locale(__cloc);
> }
>
> template<typename _CharT>
> typename messages<_CharT>::catalog
> messages<_CharT>::open(const basic_string<char>& __s, const locale& __loc,
> const char* __dir) const
> {
> bindtextdomain(__s.c_str(), __dir);
> return this->do_open(__s, __loc);
> }
>
>
> template<typename _CharT>
> messages<_CharT>::~messages()
> {
> if (_M_name_messages != _S_get_c_name())
> delete [] _M_name_messages;
> _S_destroy_c_locale(_M_c_locale_messages);
> }
>
> template<typename _CharT>
> typename messages<_CharT>::catalog
> messages<_CharT>::do_open(const basic_string<char>& __s,
> const locale&) const
> {
>
>
> textdomain(__s.c_str());
> return 0;
> }
>
> template<typename _CharT>
> void
> messages<_CharT>::do_close(catalog) const
> { }
>
>
> template<typename _CharT>
> messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs)
> : messages<_CharT>(__refs)
> {
> if (this->_M_name_messages != locale::facet::_S_get_c_name())
> {
> delete [] this->_M_name_messages;
> if (__builtin_strcmp(__s, locale::facet::_S_get_c_name()) != 0)
> {
> const size_t __len = __builtin_strlen(__s) + 1;
> char* __tmp = new char[__len];
> __builtin_memcpy(__tmp, __s, __len);
> this->_M_name_messages = __tmp;
> }
> else
> this->_M_name_messages = locale::facet::_S_get_c_name();
> }
>
> if (__builtin_strcmp(__s, "C") != 0
> && __builtin_strcmp(__s, "POSIX") != 0)
> {
> this->_S_destroy_c_locale(this->_M_c_locale_messages);
> this->_S_create_c_locale(this->_M_c_locale_messages, __s);
> }
> }
>
>
>}
># 1899 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 2 3
>
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.tcc" 1 3
># 33 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.tcc" 3
> 
># 34 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, bool _Intl>
> struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
> {
> const __moneypunct_cache<_CharT, _Intl>*
> operator() (const locale& __loc) const
> {
> const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
> const locale::facet** __caches = __loc._M_impl->_M_caches;
> if (!__caches[__i])
> {
> __moneypunct_cache<_CharT, _Intl>* __tmp = 0;
> try
> {
> __tmp = new __moneypunct_cache<_CharT, _Intl>;
> __tmp->_M_cache(__loc);
> }
> catch(...)
> {
> delete __tmp;
> throw;
> }
> __loc._M_impl->_M_install_cache(__tmp, __i);
> }
> return static_cast<
> const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
> }
> };
>
> template<typename _CharT, bool _Intl>
> void
> __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
> {
> _M_allocated = true;
>
> const moneypunct<_CharT, _Intl>& __mp =
> use_facet<moneypunct<_CharT, _Intl> >(__loc);
>
> _M_decimal_point = __mp.decimal_point();
> _M_thousands_sep = __mp.thousands_sep();
> _M_frac_digits = __mp.frac_digits();
>
> char* __grouping = 0;
> _CharT* __curr_symbol = 0;
> _CharT* __positive_sign = 0;
> _CharT* __negative_sign = 0;
> try
> {
> _M_grouping_size = __mp.grouping().size();
> __grouping = new char[_M_grouping_size];
> __mp.grouping().copy(__grouping, _M_grouping_size);
> _M_grouping = __grouping;
> _M_use_grouping = (_M_grouping_size
> && static_cast<signed char>(_M_grouping[0]) > 0
> && (_M_grouping[0]
> != __gnu_cxx::__numeric_traits<char>::__max));
>
> _M_curr_symbol_size = __mp.curr_symbol().size();
> __curr_symbol = new _CharT[_M_curr_symbol_size];
> __mp.curr_symbol().copy(__curr_symbol, _M_curr_symbol_size);
> _M_curr_symbol = __curr_symbol;
>
> _M_positive_sign_size = __mp.positive_sign().size();
> __positive_sign = new _CharT[_M_positive_sign_size];
> __mp.positive_sign().copy(__positive_sign, _M_positive_sign_size);
> _M_positive_sign = __positive_sign;
>
> _M_negative_sign_size = __mp.negative_sign().size();
> __negative_sign = new _CharT[_M_negative_sign_size];
> __mp.negative_sign().copy(__negative_sign, _M_negative_sign_size);
> _M_negative_sign = __negative_sign;
>
> _M_pos_format = __mp.pos_format();
> _M_neg_format = __mp.neg_format();
>
> const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
> __ct.widen(money_base::_S_atoms,
> money_base::_S_atoms + money_base::_S_end, _M_atoms);
> }
> catch(...)
> {
> delete [] __grouping;
> delete [] __curr_symbol;
> delete [] __positive_sign;
> delete [] __negative_sign;
> throw;
> }
> }
>
>
>
> template<typename _CharT, typename _InIter>
> template<bool _Intl>
> _InIter
> money_get<_CharT, _InIter>::
> _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, string& __units) const
> {
> typedef char_traits<_CharT> __traits_type;
> typedef typename string_type::size_type size_type;
> typedef money_base::part part;
> typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
>
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> __use_cache<__cache_type> __uc;
> const __cache_type* __lc = __uc(__loc);
> const char_type* __lit = __lc->_M_atoms;
>
>
> bool __negative = false;
>
> size_type __sign_size = 0;
>
> const bool __mandatory_sign = (__lc->_M_positive_sign_size
> && __lc->_M_negative_sign_size);
>
> string __grouping_tmp;
> if (__lc->_M_use_grouping)
> __grouping_tmp.reserve(32);
>
> int __last_pos = 0;
>
> int __n = 0;
>
> bool __testvalid = true;
>
> bool __testdecfound = false;
>
>
> string __res;
> __res.reserve(32);
>
> const char_type* __lit_zero = __lit + money_base::_S_zero;
> const money_base::pattern __p = __lc->_M_neg_format;
> for (int __i = 0; __i < 4 && __testvalid; ++__i)
> {
> const part __which = static_cast<part>(__p.field[__i]);
> switch (__which)
> {
> case money_base::symbol:
>
>
>
>
> if (__io.flags() & ios_base::showbase || __sign_size > 1
> || __i == 0
> || (__i == 1 && (__mandatory_sign
> || (static_cast<part>(__p.field[0])
> == money_base::sign)
> || (static_cast<part>(__p.field[2])
> == money_base::space)))
> || (__i == 2 && ((static_cast<part>(__p.field[3])
> == money_base::value)
> || (__mandatory_sign
> && (static_cast<part>(__p.field[3])
> == money_base::sign)))))
> {
> const size_type __len = __lc->_M_curr_symbol_size;
> size_type __j = 0;
> for (; __beg != __end && __j < __len
> && *__beg == __lc->_M_curr_symbol[__j];
> ++__beg, ++__j);
> if (__j != __len
> && (__j || __io.flags() & ios_base::showbase))
> __testvalid = false;
> }
> break;
> case money_base::sign:
>
> if (__lc->_M_positive_sign_size && __beg != __end
> && *__beg == __lc->_M_positive_sign[0])
> {
> __sign_size = __lc->_M_positive_sign_size;
> ++__beg;
> }
> else if (__lc->_M_negative_sign_size && __beg != __end
> && *__beg == __lc->_M_negative_sign[0])
> {
> __negative = true;
> __sign_size = __lc->_M_negative_sign_size;
> ++__beg;
> }
> else if (__lc->_M_positive_sign_size
> && !__lc->_M_negative_sign_size)
>
>
> __negative = true;
> else if (__mandatory_sign)
> __testvalid = false;
> break;
> case money_base::value:
>
>
> for (; __beg != __end; ++__beg)
> {
> const char_type __c = *__beg;
> const char_type* __q = __traits_type::find(__lit_zero,
> 10, __c);
> if (__q != 0)
> {
> __res += money_base::_S_atoms[__q - __lit];
> ++__n;
> }
> else if (__c == __lc->_M_decimal_point
> && !__testdecfound)
> {
> if (__lc->_M_frac_digits <= 0)
> break;
>
> __last_pos = __n;
> __n = 0;
> __testdecfound = true;
> }
> else if (__lc->_M_use_grouping
> && __c == __lc->_M_thousands_sep
> && !__testdecfound)
> {
> if (__n)
> {
>
> __grouping_tmp += static_cast<char>(__n);
> __n = 0;
> }
> else
> {
> __testvalid = false;
> break;
> }
> }
> else
> break;
> }
> if (__res.empty())
> __testvalid = false;
> break;
> case money_base::space:
>
> if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
> ++__beg;
> else
> __testvalid = false;
> case money_base::none:
>
> if (__i != 3)
> for (; __beg != __end
> && __ctype.is(ctype_base::space, *__beg); ++__beg);
> break;
> }
> }
>
>
> if (__sign_size > 1 && __testvalid)
> {
> const char_type* __sign = __negative ? __lc->_M_negative_sign
> : __lc->_M_positive_sign;
> size_type __i = 1;
> for (; __beg != __end && __i < __sign_size
> && *__beg == __sign[__i]; ++__beg, ++__i);
>
> if (__i != __sign_size)
> __testvalid = false;
> }
>
> if (__testvalid)
> {
>
> if (__res.size() > 1)
> {
> const size_type __first = __res.find_first_not_of('0');
> const bool __only_zeros = __first == string::npos;
> if (__first)
> __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
> }
>
>
> if (__negative && __res[0] != '0')
> __res.insert(__res.begin(), '-');
>
>
> if (__grouping_tmp.size())
> {
>
> __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
> : __n);
> if (!std::__verify_grouping(__lc->_M_grouping,
> __lc->_M_grouping_size,
> __grouping_tmp))
> __err |= ios_base::failbit;
> }
>
>
> if (__testdecfound && __n != __lc->_M_frac_digits)
> __testvalid = false;
> }
>
>
> if (!__testvalid)
> __err |= ios_base::failbit;
> else
> __units.swap(__res);
>
>
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
># 362 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.tcc" 3
> template<typename _CharT, typename _InIter>
> _InIter
> money_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, long double& __units) const
> {
> string __str;
> __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
> : _M_extract<false>(__beg, __end, __io, __err, __str);
> std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> money_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, string_type& __digits) const
> {
> typedef typename string::size_type size_type;
>
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> string __str;
> __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
> : _M_extract<false>(__beg, __end, __io, __err, __str);
> const size_type __len = __str.size();
> if (__len)
> {
> __digits.resize(__len);
> __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
> }
> return __beg;
> }
>
> template<typename _CharT, typename _OutIter>
> template<bool _Intl>
> _OutIter
> money_put<_CharT, _OutIter>::
> _M_insert(iter_type __s, ios_base& __io, char_type __fill,
> const string_type& __digits) const
> {
> typedef typename string_type::size_type size_type;
> typedef money_base::part part;
> typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
>
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> __use_cache<__cache_type> __uc;
> const __cache_type* __lc = __uc(__loc);
> const char_type* __lit = __lc->_M_atoms;
>
>
>
> const char_type* __beg = __digits.data();
>
> money_base::pattern __p;
> const char_type* __sign;
> size_type __sign_size;
> if (!(*__beg == __lit[money_base::_S_minus]))
> {
> __p = __lc->_M_pos_format;
> __sign = __lc->_M_positive_sign;
> __sign_size = __lc->_M_positive_sign_size;
> }
> else
> {
> __p = __lc->_M_neg_format;
> __sign = __lc->_M_negative_sign;
> __sign_size = __lc->_M_negative_sign_size;
> if (__digits.size())
> ++__beg;
> }
>
>
> size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
> __beg + __digits.size()) - __beg;
> if (__len)
> {
>
>
>
> string_type __value;
> __value.reserve(2 * __len);
>
>
>
> long __paddec = __len - __lc->_M_frac_digits;
> if (__paddec > 0)
> {
> if (__lc->_M_frac_digits < 0)
> __paddec = __len;
> if (__lc->_M_grouping_size)
> {
> __value.assign(2 * __paddec, char_type());
> _CharT* __vend =
> std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
> __lc->_M_grouping,
> __lc->_M_grouping_size,
> __beg, __beg + __paddec);
> __value.erase(__vend - &__value[0]);
> }
> else
> __value.assign(__beg, __paddec);
> }
>
>
> if (__lc->_M_frac_digits > 0)
> {
> __value += __lc->_M_decimal_point;
> if (__paddec >= 0)
> __value.append(__beg + __paddec, __lc->_M_frac_digits);
> else
> {
>
> __value.append(-__paddec, __lit[money_base::_S_zero]);
> __value.append(__beg, __len);
> }
> }
>
>
> const ios_base::fmtflags __f = __io.flags()
> & ios_base::adjustfield;
> __len = __value.size() + __sign_size;
> __len += ((__io.flags() & ios_base::showbase)
> ? __lc->_M_curr_symbol_size : 0);
>
> string_type __res;
> __res.reserve(2 * __len);
>
> const size_type __width = static_cast<size_type>(__io.width());
> const bool __testipad = (__f == ios_base::internal
> && __len < __width);
>
> for (int __i = 0; __i < 4; ++__i)
> {
> const part __which = static_cast<part>(__p.field[__i]);
> switch (__which)
> {
> case money_base::symbol:
> if (__io.flags() & ios_base::showbase)
> __res.append(__lc->_M_curr_symbol,
> __lc->_M_curr_symbol_size);
> break;
> case money_base::sign:
>
>
>
> if (__sign_size)
> __res += __sign[0];
> break;
> case money_base::value:
> __res += __value;
> break;
> case money_base::space:
>
>
>
> if (__testipad)
> __res.append(__width - __len, __fill);
> else
> __res += __fill;
> break;
> case money_base::none:
> if (__testipad)
> __res.append(__width - __len, __fill);
> break;
> }
> }
>
>
> if (__sign_size > 1)
> __res.append(__sign + 1, __sign_size - 1);
>
>
> __len = __res.size();
> if (__width > __len)
> {
> if (__f == ios_base::left)
>
> __res.append(__width - __len, __fill);
> else
>
> __res.insert(0, __width - __len, __fill);
> __len = __width;
> }
>
>
> __s = std::__write(__s, __res.data(), __len);
> }
> __io.width(0);
> return __s;
> }
># 567 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.tcc" 3
> template<typename _CharT, typename _OutIter>
> _OutIter
> money_put<_CharT, _OutIter>::
> do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
> long double __units) const
> {
> const locale __loc = __io.getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
>
> int __cs_size = 64;
> char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
>
>
> int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
> "%.*Lf", 0, __units);
>
> if (__len >= __cs_size)
> {
> __cs_size = __len + 1;
> __cs = static_cast<char*>(__builtin_alloca(__cs_size));
> __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
> "%.*Lf", 0, __units);
> }
># 599 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.tcc" 3
> string_type __digits(__len, char_type());
> __ctype.widen(__cs, __cs + __len, &__digits[0]);
> return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
> : _M_insert<false>(__s, __io, __fill, __digits);
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> money_put<_CharT, _OutIter>::
> do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
> const string_type& __digits) const
> { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
> : _M_insert<false>(__s, __io, __fill, __digits); }
>
>
>
>
>
>
> template<typename _CharT, typename _InIter>
> time_base::dateorder
> time_get<_CharT, _InIter>::do_date_order() const
> { return time_base::no_order; }
>
>
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm,
> const _CharT* __format) const
> {
> const locale& __loc = __io._M_getloc();
> const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
> const size_t __len = char_traits<_CharT>::length(__format);
>
> ios_base::iostate __tmperr = ios_base::goodbit;
> size_t __i = 0;
> for (; __beg != __end && __i < __len && !__tmperr; ++__i)
> {
> if (__ctype.narrow(__format[__i], 0) == '%')
> {
>
> char __c = __ctype.narrow(__format[++__i], 0);
> int __mem = 0;
> if (__c == 'E' || __c == 'O')
> __c = __ctype.narrow(__format[++__i], 0);
> switch (__c)
> {
> const char* __cs;
> _CharT __wcs[10];
> case 'a':
>
> const char_type* __days1[7];
> __tp._M_days_abbreviated(__days1);
> __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
> 7, __io, __tmperr);
> break;
> case 'A':
>
> const char_type* __days2[7];
> __tp._M_days(__days2);
> __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
> 7, __io, __tmperr);
> break;
> case 'h':
> case 'b':
>
> const char_type* __months1[12];
> __tp._M_months_abbreviated(__months1);
> __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
> __months1, 12, __io, __tmperr);
> break;
> case 'B':
>
> const char_type* __months2[12];
> __tp._M_months(__months2);
> __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
> __months2, 12, __io, __tmperr);
> break;
> case 'c':
>
> const char_type* __dt[2];
> __tp._M_date_time_formats(__dt);
> __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
> __tm, __dt[0]);
> break;
> case 'd':
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
> __io, __tmperr);
> break;
> case 'e':
>
>
> if (__ctype.is(ctype_base::space, *__beg))
> __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
> 1, __io, __tmperr);
> else
> __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
> 2, __io, __tmperr);
> break;
> case 'D':
>
> __cs = "%m/%d/%y";
> __ctype.widen(__cs, __cs + 9, __wcs);
> __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
> __tm, __wcs);
> break;
> case 'H':
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
> __io, __tmperr);
> break;
> case 'I':
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
> __io, __tmperr);
> break;
> case 'm':
>
> __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
> __io, __tmperr);
> if (!__tmperr)
> __tm->tm_mon = __mem - 1;
> break;
> case 'M':
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
> __io, __tmperr);
> break;
> case 'n':
> if (__ctype.narrow(*__beg, 0) == '\n')
> ++__beg;
> else
> __tmperr |= ios_base::failbit;
> break;
> case 'R':
>
> __cs = "%H:%M";
> __ctype.widen(__cs, __cs + 6, __wcs);
> __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
> __tm, __wcs);
> break;
> case 'S':
>
>
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,
>
>
>
> __io, __tmperr);
> break;
> case 't':
> if (__ctype.narrow(*__beg, 0) == '\t')
> ++__beg;
> else
> __tmperr |= ios_base::failbit;
> break;
> case 'T':
>
> __cs = "%H:%M:%S";
> __ctype.widen(__cs, __cs + 9, __wcs);
> __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
> __tm, __wcs);
> break;
> case 'x':
>
> const char_type* __dates[2];
> __tp._M_date_formats(__dates);
> __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
> __tm, __dates[0]);
> break;
> case 'X':
>
> const char_type* __times[2];
> __tp._M_time_formats(__times);
> __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
> __tm, __times[0]);
> break;
> case 'y':
> case 'C':
>
> case 'Y':
>
>
>
>
> __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
> __io, __tmperr);
> if (!__tmperr)
> __tm->tm_year = __mem < 0 ? __mem + 100 : __mem - 1900;
> break;
> case 'Z':
>
> if (__ctype.is(ctype_base::upper, *__beg))
> {
> int __tmp;
> __beg = _M_extract_name(__beg, __end, __tmp,
> __timepunct_cache<_CharT>::_S_timezones,
> 14, __io, __tmperr);
>
>
> if (__beg != __end && !__tmperr && __tmp == 0
> && (*__beg == __ctype.widen('-')
> || *__beg == __ctype.widen('+')))
> {
> __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
> __io, __tmperr);
> __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
> __io, __tmperr);
> }
> }
> else
> __tmperr |= ios_base::failbit;
> break;
> default:
>
> __tmperr |= ios_base::failbit;
> }
> }
> else
> {
>
> if (__format[__i] == *__beg)
> ++__beg;
> else
> __tmperr |= ios_base::failbit;
> }
> }
>
> if (__tmperr || __i != __len)
> __err |= ios_base::failbit;
>
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> _M_extract_num(iter_type __beg, iter_type __end, int& __member,
> int __min, int __max, size_t __len,
> ios_base& __io, ios_base::iostate& __err) const
> {
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
>
> int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
>
> ++__min;
> size_t __i = 0;
> int __value = 0;
> for (; __beg != __end && __i < __len; ++__beg, ++__i)
> {
> const char __c = __ctype.narrow(*__beg, '*');
> if (__c >= '0' && __c <= '9')
> {
> __value = __value * 10 + (__c - '0');
> const int __valuec = __value * __mult;
> if (__valuec > __max || __valuec + __mult < __min)
> break;
> __mult /= 10;
> }
> else
> break;
> }
> if (__i == __len)
> __member = __value;
>
> else if (__len == 4 && __i == 2)
> __member = __value - 100;
> else
> __err |= ios_base::failbit;
>
> return __beg;
> }
>
>
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> _M_extract_name(iter_type __beg, iter_type __end, int& __member,
> const _CharT** __names, size_t __indexlen,
> ios_base& __io, ios_base::iostate& __err) const
> {
> typedef char_traits<_CharT> __traits_type;
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
> * __indexlen));
> size_t __nmatches = 0;
> size_t __pos = 0;
> bool __testvalid = true;
> const char_type* __name;
>
>
>
>
>
> if (__beg != __end)
> {
> const char_type __c = *__beg;
> for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
> if (__c == __names[__i1][0]
> || __c == __ctype.toupper(__names[__i1][0]))
> __matches[__nmatches++] = __i1;
> }
>
> while (__nmatches > 1)
> {
>
> size_t __minlen = __traits_type::length(__names[__matches[0]]);
> for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
> __minlen = std::min(__minlen,
> __traits_type::length(__names[__matches[__i2]]));
> ++__beg, ++__pos;
> if (__pos < __minlen && __beg != __end)
> for (size_t __i3 = 0; __i3 < __nmatches;)
> {
> __name = __names[__matches[__i3]];
> if (!(__name[__pos] == *__beg))
> __matches[__i3] = __matches[--__nmatches];
> else
> ++__i3;
> }
> else
> break;
> }
>
> if (__nmatches == 1)
> {
>
> ++__beg, ++__pos;
> __name = __names[__matches[0]];
> const size_t __len = __traits_type::length(__name);
> while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
> ++__beg, ++__pos;
>
> if (__len == __pos)
> __member = __matches[0];
> else
> __testvalid = false;
> }
> else
> __testvalid = false;
> if (!__testvalid)
> __err |= ios_base::failbit;
>
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
> const _CharT** __names, size_t __indexlen,
> ios_base& __io, ios_base::iostate& __err) const
> {
> typedef char_traits<_CharT> __traits_type;
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> int* __matches = static_cast<int*>(__builtin_alloca(2 * sizeof(int)
> * __indexlen));
> size_t __nmatches = 0;
> size_t* __matches_lengths = 0;
> size_t __pos = 0;
>
> if (__beg != __end)
> {
> const char_type __c = *__beg;
> for (size_t __i = 0; __i < 2 * __indexlen; ++__i)
> if (__c == __names[__i][0]
> || __c == __ctype.toupper(__names[__i][0]))
> __matches[__nmatches++] = __i;
> }
>
> if (__nmatches)
> {
> ++__beg, ++__pos;
>
> __matches_lengths
> = static_cast<size_t*>(__builtin_alloca(sizeof(size_t)
> * __nmatches));
> for (size_t __i = 0; __i < __nmatches; ++__i)
> __matches_lengths[__i]
> = __traits_type::length(__names[__matches[__i]]);
> }
>
> for (; __beg != __end; ++__beg, ++__pos)
> {
> size_t __nskipped = 0;
> const char_type __c = *__beg;
> for (size_t __i = 0; __i < __nmatches;)
> {
> const char_type* __name = __names[__matches[__i]];
> if (__pos >= __matches_lengths[__i])
> ++__nskipped, ++__i;
> else if (!(__name[__pos] == __c))
> {
> --__nmatches;
> __matches[__i] = __matches[__nmatches];
> __matches_lengths[__i] = __matches_lengths[__nmatches];
> }
> else
> ++__i;
> }
> if (__nskipped == __nmatches)
> break;
> }
>
> if ((__nmatches == 1 && __matches_lengths[0] == __pos)
> || (__nmatches == 2 && (__matches_lengths[0] == __pos
> || __matches_lengths[1] == __pos)))
> __member = (__matches[0] >= __indexlen
> ? __matches[0] - __indexlen : __matches[0]);
> else
> __err |= ios_base::failbit;
>
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> {
> const locale& __loc = __io._M_getloc();
> const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
> const char_type* __times[2];
> __tp._M_time_formats(__times);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __times[0]);
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> {
> const locale& __loc = __io._M_getloc();
> const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
> const char_type* __dates[2];
> __tp._M_date_formats(__dates);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __dates[0]);
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> {
> typedef char_traits<_CharT> __traits_type;
> const locale& __loc = __io._M_getloc();
> const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
> const char_type* __days[14];
> __tp._M_days_abbreviated(__days);
> __tp._M_days(__days + 7);
> int __tmpwday;
> ios_base::iostate __tmperr = ios_base::goodbit;
>
> __beg = _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, 7,
> __io, __tmperr);
> if (!__tmperr)
> __tm->tm_wday = __tmpwday;
> else
> __err |= ios_base::failbit;
>
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> do_get_monthname(iter_type __beg, iter_type __end,
> ios_base& __io, ios_base::iostate& __err, tm* __tm) const
> {
> typedef char_traits<_CharT> __traits_type;
> const locale& __loc = __io._M_getloc();
> const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
> const char_type* __months[24];
> __tp._M_months_abbreviated(__months);
> __tp._M_months(__months + 12);
> int __tmpmon;
> ios_base::iostate __tmperr = ios_base::goodbit;
>
> __beg = _M_extract_wday_or_month(__beg, __end, __tmpmon, __months, 12,
> __io, __tmperr);
> if (!__tmperr)
> __tm->tm_mon = __tmpmon;
> else
> __err |= ios_base::failbit;
>
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> {
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
> int __tmpyear;
> ios_base::iostate __tmperr = ios_base::goodbit;
>
> __beg = _M_extract_num(__beg, __end, __tmpyear, 0, 9999, 4,
> __io, __tmperr);
> if (!__tmperr)
> __tm->tm_year = __tmpyear < 0 ? __tmpyear + 100 : __tmpyear - 1900;
> else
> __err |= ios_base::failbit;
>
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> time_put<_CharT, _OutIter>::
> put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
> const _CharT* __beg, const _CharT* __end) const
> {
> const locale& __loc = __io._M_getloc();
> ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
> for (; __beg != __end; ++__beg)
> if (__ctype.narrow(*__beg, 0) != '%')
> {
> *__s = *__beg;
> ++__s;
> }
> else if (++__beg != __end)
> {
> char __format;
> char __mod = 0;
> const char __c = __ctype.narrow(*__beg, 0);
> if (__c != 'E' && __c != 'O')
> __format = __c;
> else if (++__beg != __end)
> {
> __mod = __c;
> __format = __ctype.narrow(*__beg, 0);
> }
> else
> break;
> __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
> }
> else
> break;
> return __s;
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> time_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
> char __format, char __mod) const
> {
> const locale& __loc = __io._M_getloc();
> ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
> __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
>
>
>
> const size_t __maxlen = 128;
> char_type __res[__maxlen];
>
>
>
>
>
>
> char_type __fmt[4];
> __fmt[0] = __ctype.widen('%');
> if (!__mod)
> {
> __fmt[1] = __format;
> __fmt[2] = char_type();
> }
> else
> {
> __fmt[1] = __mod;
> __fmt[2] = __format;
> __fmt[3] = char_type();
> }
>
> __tp._M_put(__res, __maxlen, __fmt, __tm);
>
>
> return std::__write(__s, __res, char_traits<char_type>::length(__res));
> }
>
>
>
>
>
> extern template class moneypunct<char, false>;
> extern template class moneypunct<char, true>;
> extern template class moneypunct_byname<char, false>;
> extern template class moneypunct_byname<char, true>;
> extern template class money_get<char>;
> extern template class money_put<char>;
> extern template class __timepunct<char>;
> extern template class time_put<char>;
> extern template class time_put_byname<char>;
> extern template class time_get<char>;
> extern template class time_get_byname<char>;
> extern template class messages<char>;
> extern template class messages_byname<char>;
>
> extern template
> const moneypunct<char, true>&
> use_facet<moneypunct<char, true> >(const locale&);
>
> extern template
> const moneypunct<char, false>&
> use_facet<moneypunct<char, false> >(const locale&);
>
> extern template
> const money_put<char>&
> use_facet<money_put<char> >(const locale&);
>
> extern template
> const money_get<char>&
> use_facet<money_get<char> >(const locale&);
>
> extern template
> const __timepunct<char>&
> use_facet<__timepunct<char> >(const locale&);
>
> extern template
> const time_put<char>&
> use_facet<time_put<char> >(const locale&);
>
> extern template
> const time_get<char>&
> use_facet<time_get<char> >(const locale&);
>
> extern template
> const messages<char>&
> use_facet<messages<char> >(const locale&);
>
> extern template
> bool
> has_facet<moneypunct<char> >(const locale&);
>
> extern template
> bool
> has_facet<money_put<char> >(const locale&);
>
> extern template
> bool
> has_facet<money_get<char> >(const locale&);
>
> extern template
> bool
> has_facet<__timepunct<char> >(const locale&);
>
> extern template
> bool
> has_facet<time_put<char> >(const locale&);
>
> extern template
> bool
> has_facet<time_get<char> >(const locale&);
>
> extern template
> bool
> has_facet<messages<char> >(const locale&);
>
>
> extern template class moneypunct<wchar_t, false>;
> extern template class moneypunct<wchar_t, true>;
> extern template class moneypunct_byname<wchar_t, false>;
> extern template class moneypunct_byname<wchar_t, true>;
> extern template class money_get<wchar_t>;
> extern template class money_put<wchar_t>;
> extern template class __timepunct<wchar_t>;
> extern template class time_put<wchar_t>;
> extern template class time_put_byname<wchar_t>;
> extern template class time_get<wchar_t>;
> extern template class time_get_byname<wchar_t>;
> extern template class messages<wchar_t>;
> extern template class messages_byname<wchar_t>;
>
> extern template
> const moneypunct<wchar_t, true>&
> use_facet<moneypunct<wchar_t, true> >(const locale&);
>
> extern template
> const moneypunct<wchar_t, false>&
> use_facet<moneypunct<wchar_t, false> >(const locale&);
>
> extern template
> const money_put<wchar_t>&
> use_facet<money_put<wchar_t> >(const locale&);
>
> extern template
> const money_get<wchar_t>&
> use_facet<money_get<wchar_t> >(const locale&);
>
> extern template
> const __timepunct<wchar_t>&
> use_facet<__timepunct<wchar_t> >(const locale&);
>
> extern template
> const time_put<wchar_t>&
> use_facet<time_put<wchar_t> >(const locale&);
>
> extern template
> const time_get<wchar_t>&
> use_facet<time_get<wchar_t> >(const locale&);
>
> extern template
> const messages<wchar_t>&
> use_facet<messages<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<moneypunct<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<money_put<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<money_get<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<__timepunct<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<time_put<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<time_get<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<messages<wchar_t> >(const locale&);
>
>
>
>
>}
># 1904 "/usr/include/c++/4.8.2/bits/locale_facets_nonio.h" 2 3
># 42 "/usr/include/c++/4.8.2/locale" 2 3
># 30 "/usr/include/boost/filesystem/path_traits.hpp" 2 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 31 "/usr/include/boost/filesystem/path_traits.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 34 "/usr/include/boost/filesystem/path_traits.hpp" 2 3 4
>
>namespace boost { namespace filesystem {
>
> const system::error_category& codecvt_error_category();
># 48 "/usr/include/boost/filesystem/path_traits.hpp" 3 4
> class directory_entry;
>
>namespace path_traits {
>
> typedef std::codecvt<wchar_t, char, std::mbstate_t> codecvt_type;
>
>
>
> template <class T>
> struct is_pathable { static const bool value = false; };
>
> template<> struct is_pathable<char*> { static const bool value = true; };
> template<> struct is_pathable<const char*> { static const bool value = true; };
> template<> struct is_pathable<wchar_t*> { static const bool value = true; };
> template<> struct is_pathable<const wchar_t*> { static const bool value = true; };
> template<> struct is_pathable<std::string> { static const bool value = true; };
> template<> struct is_pathable<std::wstring> { static const bool value = true; };
> template<> struct is_pathable<std::vector<char> > { static const bool value = true; };
> template<> struct is_pathable<std::vector<wchar_t> > { static const bool value = true; };
> template<> struct is_pathable<std::list<char> > { static const bool value = true; };
> template<> struct is_pathable<std::list<wchar_t> > { static const bool value = true; };
> template<> struct is_pathable<directory_entry> { static const bool value = true; };
>
>
>
> template <class Container> inline
>
>
> typename boost::disable_if<boost::is_array<Container>, bool>::type
> empty(const Container & c)
> { return c.begin() == c.end(); }
>
> template <class T> inline
> bool empty(T * const & c_str)
> {
> ((void)0);
> return !*c_str;
> }
>
> template <typename T, size_t N> inline
> bool empty(T (&x)[N])
> { return !x[0]; }
>
>
>
>
>
> 
> void convert(const char* from,
> const char* from_end,
> std::wstring & to,
> const codecvt_type& cvt);
>
> 
> void convert(const wchar_t* from,
> const wchar_t* from_end,
> std::string & to,
> const codecvt_type& cvt);
>
> inline
> void convert(const char* from,
> std::wstring & to,
> const codecvt_type& cvt)
> {
> ((void)0);
> convert(from, 0, to, cvt);
> }
>
> inline
> void convert(const wchar_t* from,
> std::string & to,
> const codecvt_type& cvt)
> {
> ((void)0);
> convert(from, 0, to, cvt);
> }
>
>
>
>
>
> inline
> void convert(const char* from, const char* from_end, std::string & to,
> const codecvt_type&)
> {
> ((void)0);
> ((void)0);
> to.append(from, from_end);
> }
>
> inline
> void convert(const char* from,
> std::string & to,
> const codecvt_type&)
> {
> ((void)0);
> to += from;
> }
>
>
>
> inline
> void convert(const wchar_t* from, const wchar_t* from_end, std::wstring & to,
> const codecvt_type&)
> {
> ((void)0);
> ((void)0);
> to.append(from, from_end);
> }
>
> inline
> void convert(const wchar_t* from,
> std::wstring & to,
> const codecvt_type&)
> {
> ((void)0);
> to += from;
> }
>
>
>
>
> template <class U> inline
> void dispatch(const std::string& c, U& to, const codecvt_type& cvt)
> {
> if (c.size())
> convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
> }
> template <class U> inline
> void dispatch(const std::wstring& c, U& to, const codecvt_type& cvt)
> {
> if (c.size())
> convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
> }
> template <class U> inline
> void dispatch(const std::vector<char>& c, U& to, const codecvt_type& cvt)
> {
> if (c.size())
> convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
> }
> template <class U> inline
> void dispatch(const std::vector<wchar_t>& c, U& to, const codecvt_type& cvt)
> {
> if (c.size())
> convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
> }
>
>
> template <class Container, class U> inline
>
>
> typename boost::disable_if<boost::is_array<Container>, void>::type
> dispatch(const Container & c, U& to, const codecvt_type& cvt)
> {
> if (c.size())
> {
> std::basic_string<typename Container::value_type> s(c.begin(), c.end());
> convert(s.c_str(), s.c_str()+s.size(), to, cvt);
> }
> }
>
>
> template <class T, class U> inline
> void dispatch(T * const & c_str, U& to, const codecvt_type& cvt)
> {
>
> ((void)0);
> convert(c_str, to, cvt);
> }
>
>
>
>
> 
> void dispatch(const directory_entry & de,
>
>
>
> std::string & to,
>
> const codecvt_type&);
>
>
>}}}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 234 "/usr/include/boost/filesystem/path_traits.hpp" 2 3 4
># 26 "/usr/include/boost/filesystem/path.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/io/detail/quoted_manip.hpp" 1 3 4
># 19 "/usr/include/boost/io/detail/quoted_manip.hpp" 3 4
># 1 "/usr/include/boost/io/ios_state.hpp" 1 3 4
># 12 "/usr/include/boost/io/ios_state.hpp" 3 4
># 1 "/usr/include/boost/io_fwd.hpp" 1 3 4
># 15 "/usr/include/boost/io_fwd.hpp" 3 4
>namespace boost
>{
>namespace io
>{
>
>
>
>
>class ios_flags_saver;
>class ios_precision_saver;
>class ios_width_saver;
>class ios_base_all_saver;
>
>template < typename Ch, class Tr = ::std::char_traits<Ch> >
> class basic_ios_iostate_saver;
>template < typename Ch, class Tr = ::std::char_traits<Ch> >
> class basic_ios_exception_saver;
>template < typename Ch, class Tr = ::std::char_traits<Ch> >
> class basic_ios_tie_saver;
>template < typename Ch, class Tr = ::std::char_traits<Ch> >
> class basic_ios_rdbuf_saver;
>template < typename Ch, class Tr = ::std::char_traits<Ch> >
> class basic_ios_fill_saver;
>template < typename Ch, class Tr = ::std::char_traits<Ch> >
> class basic_ios_locale_saver;
>template < typename Ch, class Tr = ::std::char_traits<Ch> >
> class basic_ios_all_saver;
>
>typedef basic_ios_iostate_saver<char> ios_iostate_saver;
>typedef basic_ios_iostate_saver<wchar_t> wios_iostate_saver;
>typedef basic_ios_exception_saver<char> ios_exception_saver;
>typedef basic_ios_exception_saver<wchar_t> wios_exception_saver;
>typedef basic_ios_tie_saver<char> ios_tie_saver;
>typedef basic_ios_tie_saver<wchar_t> wios_tie_saver;
>typedef basic_ios_rdbuf_saver<char> ios_rdbuf_saver;
>typedef basic_ios_rdbuf_saver<wchar_t> wios_rdbuf_saver;
>typedef basic_ios_fill_saver<char> ios_fill_saver;
>typedef basic_ios_fill_saver<wchar_t> wios_fill_saver;
>typedef basic_ios_locale_saver<char> ios_locale_saver;
>typedef basic_ios_locale_saver<wchar_t> wios_locale_saver;
>typedef basic_ios_all_saver<char> ios_all_saver;
>typedef basic_ios_all_saver<wchar_t> wios_all_saver;
>
>class ios_iword_saver;
>class ios_pword_saver;
>class ios_all_word_saver;
>
>
>}
>}
># 13 "/usr/include/boost/io/ios_state.hpp" 2 3 4
># 24 "/usr/include/boost/io/ios_state.hpp" 3 4
>namespace boost
>{
>namespace io
>{
>
>
>
>
>class ios_flags_saver
>{
>public:
> typedef ::std::ios_base state_type;
> typedef ::std::ios_base::fmtflags aspect_type;
>
> explicit ios_flags_saver( state_type &s )
> : s_save_( s ), a_save_( s.flags() )
> {}
> ios_flags_saver( state_type &s, aspect_type const &a )
> : s_save_( s ), a_save_( s.flags(a) )
> {}
> ~ios_flags_saver()
> { this->restore(); }
>
> void restore()
> { s_save_.flags( a_save_ ); }
>
>private:
> state_type & s_save_;
> aspect_type const a_save_;
>
> ios_flags_saver& operator=(const ios_flags_saver&);
>};
>
>class ios_precision_saver
>{
>public:
> typedef ::std::ios_base state_type;
> typedef ::std::streamsize aspect_type;
>
> explicit ios_precision_saver( state_type &s )
> : s_save_( s ), a_save_( s.precision() )
> {}
> ios_precision_saver( state_type &s, aspect_type const &a )
> : s_save_( s ), a_save_( s.precision(a) )
> {}
> ~ios_precision_saver()
> { this->restore(); }
>
> void restore()
> { s_save_.precision( a_save_ ); }
>
>private:
> state_type & s_save_;
> aspect_type const a_save_;
>
> ios_precision_saver& operator=(const ios_precision_saver&);
>};
>
>class ios_width_saver
>{
>public:
> typedef ::std::ios_base state_type;
> typedef ::std::streamsize aspect_type;
>
> explicit ios_width_saver( state_type &s )
> : s_save_( s ), a_save_( s.width() )
> {}
> ios_width_saver( state_type &s, aspect_type const &a )
> : s_save_( s ), a_save_( s.width(a) )
> {}
> ~ios_width_saver()
> { this->restore(); }
>
> void restore()
> { s_save_.width( a_save_ ); }
>
>private:
> state_type & s_save_;
> aspect_type const a_save_;
> ios_width_saver& operator=(const ios_width_saver&);
>};
>
>
>
>
>template < typename Ch, class Tr >
>class basic_ios_iostate_saver
>{
>public:
> typedef ::std::basic_ios<Ch, Tr> state_type;
> typedef ::std::ios_base::iostate aspect_type;
>
> explicit basic_ios_iostate_saver( state_type &s )
> : s_save_( s ), a_save_( s.rdstate() )
> {}
> basic_ios_iostate_saver( state_type &s, aspect_type const &a )
> : s_save_( s ), a_save_( s.rdstate() )
> { s.clear(a); }
> ~basic_ios_iostate_saver()
> { this->restore(); }
>
> void restore()
> { s_save_.clear( a_save_ ); }
>
>private:
> state_type & s_save_;
> aspect_type const a_save_;
> basic_ios_iostate_saver& operator=(const basic_ios_iostate_saver&);
>};
>
>template < typename Ch, class Tr >
>class basic_ios_exception_saver
>{
>public:
> typedef ::std::basic_ios<Ch, Tr> state_type;
> typedef ::std::ios_base::iostate aspect_type;
>
> explicit basic_ios_exception_saver( state_type &s )
> : s_save_( s ), a_save_( s.exceptions() )
> {}
>
>
>
> basic_ios_exception_saver( state_type &s, aspect_type const &a )
>
> : s_save_( s ), a_save_( s.exceptions() )
> { s.exceptions(a); }
> ~basic_ios_exception_saver()
> { this->restore(); }
>
> void restore()
> { s_save_.exceptions( a_save_ ); }
>
>private:
> state_type & s_save_;
> aspect_type const a_save_;
> basic_ios_exception_saver& operator=(const basic_ios_exception_saver&);
>};
>
>template < typename Ch, class Tr >
>class basic_ios_tie_saver
>{
>public:
> typedef ::std::basic_ios<Ch, Tr> state_type;
> typedef ::std::basic_ostream<Ch, Tr> * aspect_type;
>
> explicit basic_ios_tie_saver( state_type &s )
> : s_save_( s ), a_save_( s.tie() )
> {}
> basic_ios_tie_saver( state_type &s, aspect_type const &a )
> : s_save_( s ), a_save_( s.tie(a) )
> {}
> ~basic_ios_tie_saver()
> { this->restore(); }
>
> void restore()
> { s_save_.tie( a_save_ ); }
>
>private:
> state_type & s_save_;
> aspect_type const a_save_;
> basic_ios_tie_saver& operator=(const basic_ios_tie_saver&);
>};
>
>template < typename Ch, class Tr >
>class basic_ios_rdbuf_saver
>{
>public:
> typedef ::std::basic_ios<Ch, Tr> state_type;
> typedef ::std::basic_streambuf<Ch, Tr> * aspect_type;
>
> explicit basic_ios_rdbuf_saver( state_type &s )
> : s_save_( s ), a_save_( s.rdbuf() )
> {}
> basic_ios_rdbuf_saver( state_type &s, aspect_type const &a )
> : s_save_( s ), a_save_( s.rdbuf(a) )
> {}
> ~basic_ios_rdbuf_saver()
> { this->restore(); }
>
> void restore()
> { s_save_.rdbuf( a_save_ ); }
>
>private:
> state_type & s_save_;
> aspect_type const a_save_;
> basic_ios_rdbuf_saver& operator=(const basic_ios_rdbuf_saver&);
>};
>
>template < typename Ch, class Tr >
>class basic_ios_fill_saver
>{
>public:
> typedef ::std::basic_ios<Ch, Tr> state_type;
> typedef typename state_type::char_type aspect_type;
>
> explicit basic_ios_fill_saver( state_type &s )
> : s_save_( s ), a_save_( s.fill() )
> {}
> basic_ios_fill_saver( state_type &s, aspect_type const &a )
> : s_save_( s ), a_save_( s.fill(a) )
> {}
> ~basic_ios_fill_saver()
> { this->restore(); }
>
> void restore()
> { s_save_.fill( a_save_ ); }
>
>private:
> state_type & s_save_;
> aspect_type const a_save_;
> basic_ios_fill_saver& operator=(const basic_ios_fill_saver&);
>};
>
>
>template < typename Ch, class Tr >
>class basic_ios_locale_saver
>{
>public:
> typedef ::std::basic_ios<Ch, Tr> state_type;
> typedef ::std::locale aspect_type;
>
> explicit basic_ios_locale_saver( state_type &s )
> : s_save_( s ), a_save_( s.getloc() )
> {}
> basic_ios_locale_saver( state_type &s, aspect_type const &a )
> : s_save_( s ), a_save_( s.imbue(a) )
> {}
> ~basic_ios_locale_saver()
> { this->restore(); }
>
> void restore()
> { s_save_.imbue( a_save_ ); }
>
>private:
> state_type & s_save_;
> aspect_type const a_save_;
> basic_ios_locale_saver& operator=(const basic_ios_locale_saver&);
>};
>
>
>
>
>
>class ios_iword_saver
>{
>public:
> typedef ::std::ios_base state_type;
> typedef int index_type;
> typedef long aspect_type;
>
> explicit ios_iword_saver( state_type &s, index_type i )
> : s_save_( s ), a_save_( s.iword(i) ), i_save_( i )
> {}
> ios_iword_saver( state_type &s, index_type i, aspect_type const &a )
> : s_save_( s ), a_save_( s.iword(i) ), i_save_( i )
> { s.iword(i) = a; }
> ~ios_iword_saver()
> { this->restore(); }
>
> void restore()
> { s_save_.iword( i_save_ ) = a_save_; }
>
>private:
> state_type & s_save_;
> aspect_type const a_save_;
> index_type const i_save_;
>
> ios_iword_saver& operator=(const ios_iword_saver&);
>};
>
>class ios_pword_saver
>{
>public:
> typedef ::std::ios_base state_type;
> typedef int index_type;
> typedef void * aspect_type;
>
> explicit ios_pword_saver( state_type &s, index_type i )
> : s_save_( s ), a_save_( s.pword(i) ), i_save_( i )
> {}
> ios_pword_saver( state_type &s, index_type i, aspect_type const &a )
> : s_save_( s ), a_save_( s.pword(i) ), i_save_( i )
> { s.pword(i) = a; }
> ~ios_pword_saver()
> { this->restore(); }
>
> void restore()
> { s_save_.pword( i_save_ ) = a_save_; }
>
>private:
> state_type & s_save_;
> aspect_type const a_save_;
> index_type const i_save_;
>
> ios_pword_saver operator=(const ios_pword_saver&);
>};
>
>
>
>
>class ios_base_all_saver
>{
>public:
> typedef ::std::ios_base state_type;
>
> explicit ios_base_all_saver( state_type &s )
> : s_save_( s ), a1_save_( s.flags() ), a2_save_( s.precision() )
> , a3_save_( s.width() )
> {}
>
> ~ios_base_all_saver()
> { this->restore(); }
>
> void restore()
> {
> s_save_.width( a3_save_ );
> s_save_.precision( a2_save_ );
> s_save_.flags( a1_save_ );
> }
>
>private:
> state_type & s_save_;
> state_type::fmtflags const a1_save_;
> ::std::streamsize const a2_save_;
> ::std::streamsize const a3_save_;
>
> ios_base_all_saver& operator=(const ios_base_all_saver&);
>};
>
>template < typename Ch, class Tr >
>class basic_ios_all_saver
>{
>public:
> typedef ::std::basic_ios<Ch, Tr> state_type;
>
> explicit basic_ios_all_saver( state_type &s )
> : s_save_( s ), a1_save_( s.flags() ), a2_save_( s.precision() )
> , a3_save_( s.width() ), a4_save_( s.rdstate() )
> , a5_save_( s.exceptions() ), a6_save_( s.tie() )
> , a7_save_( s.rdbuf() ), a8_save_( s.fill() )
>
> , a9_save_( s.getloc() )
>
> {}
>
> ~basic_ios_all_saver()
> { this->restore(); }
>
> void restore()
> {
>
> s_save_.imbue( a9_save_ );
>
> s_save_.fill( a8_save_ );
> s_save_.rdbuf( a7_save_ );
> s_save_.tie( a6_save_ );
> s_save_.exceptions( a5_save_ );
> s_save_.clear( a4_save_ );
> s_save_.width( a3_save_ );
> s_save_.precision( a2_save_ );
> s_save_.flags( a1_save_ );
> }
>
>private:
> state_type & s_save_;
> typename state_type::fmtflags const a1_save_;
> ::std::streamsize const a2_save_;
> ::std::streamsize const a3_save_;
> typename state_type::iostate const a4_save_;
> typename state_type::iostate const a5_save_;
> ::std::basic_ostream<Ch, Tr> * const a6_save_;
> ::std::basic_streambuf<Ch, Tr> * const a7_save_;
> typename state_type::char_type const a8_save_;
>
> ::std::locale const a9_save_;
>
>
> basic_ios_all_saver& operator=(const basic_ios_all_saver&);
>};
>
>class ios_all_word_saver
>{
>public:
> typedef ::std::ios_base state_type;
> typedef int index_type;
>
> ios_all_word_saver( state_type &s, index_type i )
> : s_save_( s ), i_save_( i ), a1_save_( s.iword(i) )
> , a2_save_( s.pword(i) )
> {}
>
> ~ios_all_word_saver()
> { this->restore(); }
>
> void restore()
> {
> s_save_.pword( i_save_ ) = a2_save_;
> s_save_.iword( i_save_ ) = a1_save_;
> }
>
>private:
> state_type & s_save_;
> index_type const i_save_;
> long const a1_save_;
> void * const a2_save_;
>
> ios_all_word_saver& operator=(const ios_all_word_saver&);
>};
>
>
>}
>}
># 20 "/usr/include/boost/io/detail/quoted_manip.hpp" 2 3 4
>
>namespace boost
>{
> namespace io
> {
> namespace detail { template <class String, class Char> struct quoted_proxy; }
>
>
>
>
> template <class Char, class Traits, class Alloc>
> detail::quoted_proxy<std::basic_string<Char, Traits, Alloc> const &, Char>
> quoted(const std::basic_string<Char, Traits, Alloc>& s,
> Char escape='\\', Char delim='\"');
>
>
> template <class Char, class Traits, class Alloc>
> detail::quoted_proxy<std::basic_string<Char, Traits, Alloc> &, Char>
> quoted(std::basic_string<Char, Traits, Alloc>& s,
> Char escape='\\', Char delim='\"');
>
>
> template <class Char>
> detail::quoted_proxy<const Char*, Char>
> quoted(const Char* s, Char escape='\\', Char delim='\"');
>
>
>
> namespace detail
> {
>
> template <class String, class Char>
> struct quoted_proxy
> {
> String string;
> Char escape;
> Char delim;
>
> quoted_proxy(String s_, Char escape_, Char delim_)
> : string(s_), escape(escape_), delim(delim_) {}
> private:
>
> quoted_proxy& operator=(const quoted_proxy&);
> };
>
>
> template <class Char, class Traits, class Alloc>
> std::basic_ostream<Char, Traits>&
> basic_string_inserter_imp(std::basic_ostream<Char, Traits>& os,
> std::basic_string<Char, Traits, Alloc> const & string, Char escape, Char delim)
> {
> os << delim;
> typename std::basic_string<Char, Traits, Alloc>::const_iterator
> end_it = string.end();
> for (typename std::basic_string<Char, Traits, Alloc>::const_iterator
> it = string.begin();
> it != end_it;
> ++it )
> {
> if (*it == delim || *it == escape)
> os << escape;
> os << *it;
> }
> os << delim;
> return os;
> }
>
>
> template <class Char, class Traits, class Alloc>
> inline
> std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os,
> const quoted_proxy<std::basic_string<Char, Traits, Alloc> const &, Char>& proxy)
> {
> return basic_string_inserter_imp(os, proxy.string, proxy.escape, proxy.delim);
> }
>
>
> template <class Char, class Traits, class Alloc>
> inline
> std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os,
> const quoted_proxy<std::basic_string<Char, Traits, Alloc>&, Char>& proxy)
> {
> return basic_string_inserter_imp(os, proxy.string, proxy.escape, proxy.delim);
> }
>
>
> template <class Char, class Traits>
> std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os,
> const quoted_proxy<const Char*, Char>& proxy)
> {
> os << proxy.delim;
> for (const Char* it = proxy.string;
> *it;
> ++it )
> {
> if (*it == proxy.delim || *it == proxy.escape)
> os << proxy.escape;
> os << *it;
> }
> os << proxy.delim;
> return os;
> }
>
>
> template <class Char, class Traits, class Alloc>
> std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& is,
> const quoted_proxy<std::basic_string<Char, Traits, Alloc>&, Char>& proxy)
> {
> proxy.string.clear();
> Char c;
> is >> c;
> if (c != proxy.delim)
> {
> is.unget();
> is >> proxy.string;
> return is;
> }
> {
> boost::io::ios_flags_saver ifs(is);
> is >> std::noskipws;
> for (;;)
> {
> is >> c;
> if (!is.good())
> break;
> if (c == proxy.escape)
> {
> is >> c;
> if (!is.good())
> break;
> }
> else if (c == proxy.delim)
> break;
> proxy.string += c;
> }
> }
> return is;
> }
>
> }
>
>
> template <class Char, class Traits, class Alloc>
> inline detail::quoted_proxy<std::basic_string<Char, Traits, Alloc> const &, Char>
> quoted(const std::basic_string<Char, Traits, Alloc>& s, Char escape, Char delim)
> {
> return detail::quoted_proxy<std::basic_string<Char, Traits, Alloc> const &, Char>
> (s, escape, delim);
> }
>
>
> template <class Char, class Traits, class Alloc>
> inline detail::quoted_proxy<std::basic_string<Char, Traits, Alloc> &, Char>
> quoted(std::basic_string<Char, Traits, Alloc>& s, Char escape, Char delim)
> {
> return detail::quoted_proxy<std::basic_string<Char, Traits, Alloc>&, Char>
> (s, escape, delim);
> }
>
>
> template <class Char>
> inline detail::quoted_proxy<const Char*, Char>
> quoted(const Char* s, Char escape, Char delim)
> {
> return detail::quoted_proxy<const Char*, Char> (s, escape, delim);
> }
>
> }
>}
># 31 "/usr/include/boost/filesystem/path.hpp" 2 3 4
>
># 1 "/usr/include/boost/functional/hash_fwd.hpp" 1 3 4
># 33 "/usr/include/boost/filesystem/path.hpp" 2 3 4
>
>
>
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 37 "/usr/include/boost/filesystem/path.hpp" 2 3 4
>
>
># 1 "/usr/include/c++/4.8.2/cassert" 1 3 4
># 41 "/usr/include/c++/4.8.2/cassert" 3 4
> 
># 42 "/usr/include/c++/4.8.2/cassert" 3
>
># 1 "/usr/include/assert.h" 1 3 4
># 64 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (const char *__assertion, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 43 "/usr/include/c++/4.8.2/cassert" 2 3
># 40 "/usr/include/boost/filesystem/path.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 44 "/usr/include/boost/filesystem/path.hpp" 2 3 4
>
>namespace boost
>{
>namespace filesystem
>{
>
>
>
>
>
>
> class path
> {
> public:
># 66 "/usr/include/boost/filesystem/path.hpp" 3 4
> typedef char value_type;
> static constexpr value_type preferred_separator = '/';
>
> typedef std::basic_string<value_type> string_type;
> typedef std::codecvt<wchar_t, char,
> std::mbstate_t> codecvt_type;
># 130 "/usr/include/boost/filesystem/path.hpp" 3 4
> path(){}
>
> path(const path& p) : m_pathname(p.m_pathname) {}
>
> template <class Source>
> path(Source const& source,
> typename boost::enable_if<path_traits::is_pathable<
> typename boost::decay<Source>::type> >::type* =0)
> {
> path_traits::dispatch(source, m_pathname, codecvt());
> }
># 150 "/usr/include/boost/filesystem/path.hpp" 3 4
> path(const value_type* s) : m_pathname(s) {}
> path(const std::basic_string<value_type>& s) : m_pathname(s) {}
>
> template <class Source>
> path(Source const& source, const codecvt_type& cvt)
>
> {
> path_traits::dispatch(source, m_pathname, cvt);
> }
>
> template <class InputIterator>
> path(InputIterator begin, InputIterator end)
> {
> if (begin != end)
> {
> std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
> s(begin, end);
> path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, codecvt());
> }
> }
>
> template <class InputIterator>
> path(InputIterator begin, InputIterator end, const codecvt_type& cvt)
> {
> if (begin != end)
> {
> std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
> s(begin, end);
> path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, cvt);
> }
> }
>
>
>
> path& operator=(const path& p)
> {
> m_pathname = p.m_pathname;
> return *this;
> }
>
> path& operator=(const value_type* ptr)
> {
> m_pathname = ptr;
> return *this;
> }
>
> template <class Source>
> typename boost::enable_if<path_traits::is_pathable<
> typename boost::decay<Source>::type>, path&>::type
> operator=(Source const& source)
> {
> m_pathname.clear();
> path_traits::dispatch(source, m_pathname, codecvt());
> return *this;
> }
>
> path& assign(const value_type* ptr, const codecvt_type&)
> {
> m_pathname = ptr;
> return *this;
> }
>
> template <class Source>
> path& assign(Source const& source, const codecvt_type& cvt)
> {
> m_pathname.clear();
> path_traits::dispatch(source, m_pathname, cvt);
> return *this;
> }
>
> template <class InputIterator>
> path& assign(InputIterator begin, InputIterator end)
> {
> return assign(begin, end, codecvt());
> }
>
> template <class InputIterator>
> path& assign(InputIterator begin, InputIterator end, const codecvt_type& cvt)
> {
> m_pathname.clear();
> if (begin != end)
> {
> std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
> s(begin, end);
> path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, cvt);
> }
> return *this;
> }
>
>
>
> path& operator+=(const path& p) {m_pathname += p.m_pathname; return *this;}
> path& operator+=(const string_type& s) {m_pathname += s; return *this;}
> path& operator+=(const value_type* ptr) {m_pathname += ptr; return *this;}
> path& operator+=(value_type c) {m_pathname += c; return *this;}
>
> template <class Source>
> typename boost::enable_if<path_traits::is_pathable<
> typename boost::decay<Source>::type>, path&>::type
> operator+=(Source const& source)
> {
> return concat(source, codecvt());
> }
>
> template <class CharT>
> typename boost::enable_if<is_integral<CharT>, path&>::type
> operator+=(CharT c)
> {
> CharT tmp[2];
> tmp[0] = c;
> tmp[1] = 0;
> return concat(tmp, codecvt());
> }
>
> template <class Source>
> path& concat(Source const& source, const codecvt_type& cvt)
> {
> path_traits::dispatch(source, m_pathname, cvt);
> return *this;
> }
>
> template <class InputIterator>
> path& concat(InputIterator begin, InputIterator end)
> {
> return concat(begin, end, codecvt());
> }
>
> template <class InputIterator>
> path& concat(InputIterator begin, InputIterator end, const codecvt_type& cvt)
> {
> if (begin == end)
> return *this;
> std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
> s(begin, end);
> path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, cvt);
> return *this;
> }
>
>
>
>
>
>
> path& operator/=(const path& p);
>
> path& operator/=(const value_type* ptr);
>
> template <class Source>
> typename boost::enable_if<path_traits::is_pathable<
> typename boost::decay<Source>::type>, path&>::type
> operator/=(Source const& source)
> {
> return append(source, codecvt());
> }
>
> path& append(const value_type* ptr, const codecvt_type&)
> {
> this->operator/=(ptr);
> return *this;
> }
>
> template <class Source>
> path& append(Source const& source, const codecvt_type& cvt);
>
> template <class InputIterator>
> path& append(InputIterator begin, InputIterator end)
> {
> return append(begin, end, codecvt());
> }
>
> template <class InputIterator>
> path& append(InputIterator begin, InputIterator end, const codecvt_type& cvt);
>
>
>
> void clear() { m_pathname.clear(); }
> path& make_preferred()
>
> { return *this; }
>
>
>
> path& remove_filename();
> path& replace_extension(const path& new_extension = path());
> void swap(path& rhs) { m_pathname.swap(rhs.m_pathname); }
># 357 "/usr/include/boost/filesystem/path.hpp" 3 4
> const string_type& native() const { return m_pathname; }
> const value_type* c_str() const { return m_pathname.c_str(); }
>
> template <class String>
> String string() const;
>
> template <class String>
> String string(const codecvt_type& cvt) const;
># 383 "/usr/include/boost/filesystem/path.hpp" 3 4
> const std::string& string() const { return m_pathname; }
> const std::string& string(const codecvt_type&) const { return m_pathname; }
>
> const std::wstring wstring() const { return wstring(codecvt()); }
> const std::wstring wstring(const codecvt_type& cvt) const
> {
> std::wstring tmp;
> if (!m_pathname.empty())
> path_traits::convert(&*m_pathname.begin(), &*m_pathname.begin()+m_pathname.size(),
> tmp, cvt);
> return tmp;
> }
>
>
>
>
>
> template <class String>
> String generic_string() const;
>
> template <class String>
> String generic_string(const codecvt_type& cvt) const;
># 414 "/usr/include/boost/filesystem/path.hpp" 3 4
> const std::string& generic_string() const { return m_pathname; }
> const std::string& generic_string(const codecvt_type&) const { return m_pathname; }
> const std::wstring generic_wstring() const { return wstring(codecvt()); }
> const std::wstring generic_wstring(const codecvt_type& cvt) const { return wstring(cvt); }
>
>
>
>
>
> int compare(const path& p) const noexcept;
> int compare(const std::string& s) const { return compare(path(s)); }
> int compare(const value_type* s) const { return compare(path(s)); }
>
>
>
> path root_path() const;
> path root_name() const;
>
> path root_directory() const;
> path relative_path() const;
> path parent_path() const;
> path filename() const;
> path stem() const;
> path extension() const;
>
>
>
> bool empty() const { return m_pathname.empty(); }
> bool has_root_path() const { return has_root_directory() || has_root_name(); }
> bool has_root_name() const { return !root_name().empty(); }
> bool has_root_directory() const { return !root_directory().empty(); }
> bool has_relative_path() const { return !relative_path().empty(); }
> bool has_parent_path() const { return !parent_path().empty(); }
> bool has_filename() const { return !m_pathname.empty(); }
> bool has_stem() const { return !stem().empty(); }
> bool has_extension() const { return !extension().empty(); }
> bool is_absolute() const
> {
>
>
>
> return has_root_directory();
>
> }
> bool is_relative() const { return !is_absolute(); }
>
>
>
> class iterator;
> typedef iterator const_iterator;
>
> iterator begin() const;
> iterator end() const;
>
>
>
> static std::locale imbue(const std::locale& loc);
> static const codecvt_type& codecvt();
># 481 "/usr/include/boost/filesystem/path.hpp" 3 4
> path& normalize() { return m_normalize(); }
> path& remove_leaf() { return remove_filename(); }
> path leaf() const { return filename(); }
> path branch_path() const { return parent_path(); }
> bool has_leaf() const { return !m_pathname.empty(); }
> bool has_branch_path() const { return !parent_path().empty(); }
> bool is_complete() const { return is_absolute(); }
># 515 "/usr/include/boost/filesystem/path.hpp" 3 4
> private:
># 528 "/usr/include/boost/filesystem/path.hpp" 3 4
> string_type m_pathname;
>
>
>
>
>
> string_type::size_type m_append_separator_if_needed();
>
>
>
> void m_erase_redundant_separator(string_type::size_type sep_pos);
> string_type::size_type m_parent_path_end() const;
>
> path& m_normalize();
>
>
>
> friend class iterator;
> friend bool operator<(const path& lhs, const path& rhs);
>
>
> static void m_path_iterator_increment(path::iterator & it);
> static void m_path_iterator_decrement(path::iterator & it);
>
> };
>
> namespace detail
> {
> 
> int lex_compare(path::iterator first1, path::iterator last1,
> path::iterator first2, path::iterator last2);
> }
>
>
> typedef path wpath;
>
>
>
>
>
>
> class path::iterator
> : public boost::iterator_facade<
> path::iterator,
> path const,
> boost::bidirectional_traversal_tag >
> {
> private:
> friend class boost::iterator_core_access;
> friend class boost::filesystem::path;
> friend void m_path_iterator_increment(path::iterator & it);
> friend void m_path_iterator_decrement(path::iterator & it);
>
> const path& dereference() const { return m_element; }
>
> bool equal(const iterator & rhs) const
> {
> return m_path_ptr == rhs.m_path_ptr && m_pos == rhs.m_pos;
> }
>
>
>
> void increment() { m_path_iterator_increment(*this); }
> void decrement() { m_path_iterator_decrement(*this); }
>
> path m_element;
> const path* m_path_ptr;
> string_type::size_type m_pos;
>
>
>
>
>
> };
># 611 "/usr/include/boost/filesystem/path.hpp" 3 4
> inline bool lexicographical_compare(path::iterator first1, path::iterator last1,
> path::iterator first2, path::iterator last2)
> { return detail::lex_compare(first1, last1, first2, last2) < 0; }
>
> inline bool operator==(const path& lhs, const path& rhs) {return lhs.compare(rhs) == 0;}
> inline bool operator==(const path& lhs, const path::string_type& rhs) {return lhs.compare(rhs) == 0;}
> inline bool operator==(const path::string_type& lhs, const path& rhs) {return rhs.compare(lhs) == 0;}
> inline bool operator==(const path& lhs, const path::value_type* rhs) {return lhs.compare(rhs) == 0;}
> inline bool operator==(const path::value_type* lhs, const path& rhs) {return rhs.compare(lhs) == 0;}
>
> inline bool operator!=(const path& lhs, const path& rhs) {return lhs.compare(rhs) != 0;}
> inline bool operator!=(const path& lhs, const path::string_type& rhs) {return lhs.compare(rhs) != 0;}
> inline bool operator!=(const path::string_type& lhs, const path& rhs) {return rhs.compare(lhs) != 0;}
> inline bool operator!=(const path& lhs, const path::value_type* rhs) {return lhs.compare(rhs) != 0;}
> inline bool operator!=(const path::value_type* lhs, const path& rhs) {return rhs.compare(lhs) != 0;}
>
>
>
> inline bool operator<(const path& lhs, const path& rhs) {return lhs.compare(rhs) < 0;}
> inline bool operator<=(const path& lhs, const path& rhs) {return !(rhs < lhs);}
> inline bool operator> (const path& lhs, const path& rhs) {return rhs < lhs;}
> inline bool operator>=(const path& lhs, const path& rhs) {return !(lhs < rhs);}
>
> inline std::size_t hash_value(const path& x)
> {
>
>
>
>
>
>
> return hash_range(x.native().begin(), x.native().end());
>
> }
>
> inline void swap(path& lhs, path& rhs) { lhs.swap(rhs); }
>
> inline path operator/(const path& lhs, const path& rhs) { return path(lhs) /= rhs; }
>
>
>
>
>
> template <class Char, class Traits>
> inline std::basic_ostream<Char, Traits>&
> operator<<(std::basic_ostream<Char, Traits>& os, const path& p)
> {
> return os
> << boost::io::quoted(p.template string<std::basic_string<Char> >(), static_cast<Char>('&'));
> }
>
> template <class Char, class Traits>
> inline std::basic_istream<Char, Traits>&
> operator>>(std::basic_istream<Char, Traits>& is, path& p)
> {
> std::basic_string<Char> str;
> is >> boost::io::quoted(str, static_cast<Char>('&'));
> p = str;
> return is;
> }
>
>
>
>
>
>
> bool portable_posix_name(const std::string & name);
> bool windows_name(const std::string & name);
> bool portable_name(const std::string & name);
> bool portable_directory_name(const std::string & name);
> bool portable_file_name(const std::string & name);
> bool native(const std::string & name);
>
>
>
>
>
> template <class InputIterator>
> path& path::append(InputIterator begin, InputIterator end, const codecvt_type& cvt)
> {
> if (begin == end)
> return *this;
> string_type::size_type sep_pos(m_append_separator_if_needed());
> std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
> s(begin, end);
> path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, cvt);
> if (sep_pos)
> m_erase_redundant_separator(sep_pos);
> return *this;
> }
>
> template <class Source>
> path& path::append(Source const& source, const codecvt_type& cvt)
> {
> if (path_traits::empty(source))
> return *this;
> string_type::size_type sep_pos(m_append_separator_if_needed());
> path_traits::dispatch(source, m_pathname, cvt);
> if (sep_pos)
> m_erase_redundant_separator(sep_pos);
> return *this;
> }
>
>
>
>
>
> template <> inline
> std::string path::string<std::string>() const
> { return string(); }
>
> template <> inline
> std::wstring path::string<std::wstring>() const
> { return wstring(); }
>
> template <> inline
> std::string path::string<std::string>(const codecvt_type& cvt) const
> { return string(cvt); }
>
> template <> inline
> std::wstring path::string<std::wstring>(const codecvt_type& cvt) const
> { return wstring(cvt); }
>
> template <> inline
> std::string path::generic_string<std::string>() const
> { return generic_string(); }
>
> template <> inline
> std::wstring path::generic_string<std::wstring>() const
> { return generic_wstring(); }
>
> template <> inline
> std::string path::generic_string<std::string>(const codecvt_type& cvt) const
> { return generic_string(cvt); }
>
> template <> inline
> std::wstring path::generic_string<std::wstring>(const codecvt_type& cvt) const
> { return generic_wstring(cvt); }
>
>
>}
>}
>
>
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 757 "/usr/include/boost/filesystem/path.hpp" 2 3 4
># 17 "/usr/include/boost/filesystem.hpp" 2 3 4
># 1 "/usr/include/boost/filesystem/operations.hpp" 1 3 4
># 27 "/usr/include/boost/filesystem/operations.hpp" 3 4
># 1 "/usr/include/boost/detail/scoped_enum_emulation.hpp" 1 3 4
># 130 "/usr/include/boost/detail/scoped_enum_emulation.hpp" 3 4
>namespace boost
>{
># 198 "/usr/include/boost/detail/scoped_enum_emulation.hpp" 3 4
> template <typename EnumType>
> struct underlying_type
> {
>
> };
>
> template <typename EnumType>
> struct native_type
> {
> typedef EnumType type;
> };
>
> template <typename UnderlyingType, typename EnumType>
> UnderlyingType underlying_cast(EnumType v)
> {
> return static_cast<UnderlyingType>(v);
> }
>
> template <typename EnumType>
> inline
> EnumType native_value(EnumType e)
> {
> return e;
> }
>
>
>}
># 28 "/usr/include/boost/filesystem/operations.hpp" 2 3 4
># 1 "/usr/include/boost/detail/bitmask.hpp" 1 3 4
># 18 "/usr/include/boost/detail/bitmask.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 19 "/usr/include/boost/detail/bitmask.hpp" 2 3 4
># 29 "/usr/include/boost/filesystem/operations.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 36 "/usr/include/boost/filesystem/operations.hpp" 2 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 37 "/usr/include/boost/filesystem/operations.hpp" 2 3 4
>
>
>
># 1 "/usr/include/c++/4.8.2/ctime" 1 3 4
># 39 "/usr/include/c++/4.8.2/ctime" 3 4
> 
># 40 "/usr/include/c++/4.8.2/ctime" 3
># 41 "/usr/include/boost/filesystem/operations.hpp" 2 3 4
>
># 1 "/usr/include/c++/4.8.2/stack" 1 3 4
># 58 "/usr/include/c++/4.8.2/stack" 3 4
> 
># 59 "/usr/include/c++/4.8.2/stack" 3
>
>
># 1 "/usr/include/c++/4.8.2/bits/stl_stack.h" 1 3
># 62 "/usr/include/c++/4.8.2/bits/stl_stack.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 95 "/usr/include/c++/4.8.2/bits/stl_stack.h" 3
> template<typename _Tp, typename _Sequence = deque<_Tp> >
> class stack
> {
>
> typedef typename _Sequence::value_type _Sequence_value_type;
> 
> 
> 
>
> template<typename _Tp1, typename _Seq1>
> friend bool
> operator==(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);
>
> template<typename _Tp1, typename _Seq1>
> friend bool
> operator<(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);
>
> public:
> typedef typename _Sequence::value_type value_type;
> typedef typename _Sequence::reference reference;
> typedef typename _Sequence::const_reference const_reference;
> typedef typename _Sequence::size_type size_type;
> typedef _Sequence container_type;
>
> protected:
>
> _Sequence c;
>
> public:
># 133 "/usr/include/c++/4.8.2/bits/stl_stack.h" 3
> explicit
> stack(const _Sequence& __c)
> : c(__c) { }
>
> explicit
> stack(_Sequence&& __c = _Sequence())
> : c(std::move(__c)) { }
>
>
>
>
>
> bool
> empty() const
> { return c.empty(); }
>
>
> size_type
> size() const
> { return c.size(); }
>
>
>
>
>
> reference
> top()
> {
> ;
> return c.back();
> }
>
>
>
>
>
> const_reference
> top() const
> {
> ;
> return c.back();
> }
># 185 "/usr/include/c++/4.8.2/bits/stl_stack.h" 3
> void
> push(const value_type& __x)
> { c.push_back(__x); }
>
>
> void
> push(value_type&& __x)
> { c.push_back(std::move(__x)); }
>
> template<typename... _Args>
> void
> emplace(_Args&&... __args)
> { c.emplace_back(std::forward<_Args>(__args)...); }
># 211 "/usr/include/c++/4.8.2/bits/stl_stack.h" 3
> void
> pop()
> {
> ;
> c.pop_back();
> }
>
>
> void
> swap(stack& __s)
> noexcept(noexcept(swap(c, __s.c)))
> {
> using std::swap;
> swap(c, __s.c);
> }
>
> };
># 241 "/usr/include/c++/4.8.2/bits/stl_stack.h" 3
> template<typename _Tp, typename _Seq>
> inline bool
> operator==(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
> { return __x.c == __y.c; }
># 259 "/usr/include/c++/4.8.2/bits/stl_stack.h" 3
> template<typename _Tp, typename _Seq>
> inline bool
> operator<(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
> { return __x.c < __y.c; }
>
>
> template<typename _Tp, typename _Seq>
> inline bool
> operator!=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Tp, typename _Seq>
> inline bool
> operator>(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
> { return __y < __x; }
>
>
> template<typename _Tp, typename _Seq>
> inline bool
> operator<=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Tp, typename _Seq>
> inline bool
> operator>=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Tp, typename _Seq>
> inline void
> swap(stack<_Tp, _Seq>& __x, stack<_Tp, _Seq>& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
>
> template<typename _Tp, typename _Seq, typename _Alloc>
> struct uses_allocator<stack<_Tp, _Seq>, _Alloc>
> : public uses_allocator<_Seq, _Alloc>::type { };
>
>
>
>}
># 62 "/usr/include/c++/4.8.2/stack" 2 3
># 43 "/usr/include/boost/filesystem/operations.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 49 "/usr/include/boost/filesystem/operations.hpp" 2 3 4
>
>
>
>namespace boost
>{
> namespace filesystem
> {
>
>
>
>
>
> enum file_type
> {
> status_error,
>
> status_unknown = status_error,
>
> file_not_found,
> regular_file,
> directory_file,
>
> symlink_file,
> block_file,
> character_file,
> fifo_file,
> socket_file,
> reparse_file,
> type_unknown,
>
>
> _detail_directory_symlink
> };
>
>
>
>
>
> enum perms
> {
> no_perms = 0,
>
>
>
>
>
>
> owner_read = 0400,
> owner_write = 0200,
> owner_exe = 0100,
> owner_all = 0700,
>
> group_read = 040,
> group_write = 020,
> group_exe = 010,
> group_all = 070,
>
> others_read = 04,
> others_write = 02,
> others_exe = 01,
> others_all = 07,
>
> all_all = owner_all|group_all|others_all,
>
>
>
> set_uid_on_exe = 04000,
> set_gid_on_exe = 02000,
> sticky_bit = 01000,
>
>
>
>
>
>
> perms_mask = all_all|set_uid_on_exe|set_gid_on_exe|sticky_bit,
>
> perms_not_known = 0xFFFF,
>
>
>
> add_perms = 0x1000,
> remove_perms = 0x2000,
>
>
>
>
> symlink_perms = 0x4000
> };
>
> inline perms operator| (perms x , perms y ) { return static_cast<perms>( static_cast<boost::int_least32_t>(x) | static_cast<boost::int_least32_t>(y)); } inline perms operator& (perms x , perms y ) { return static_cast<perms>( static_cast<boost::int_least32_t>(x) & static_cast<boost::int_least32_t>(y)); } inline perms operator^ (perms x , perms y ) { return static_cast<perms>( static_cast<boost::int_least32_t>(x) ^ static_cast<boost::int_least32_t>(y)); } inline perms operator~ (perms x ) { return static_cast<perms>(~static_cast<boost::int_least32_t>(x)); } inline perms & operator&=(perms & x , perms y) { x = x & y ; return x ; } inline perms & operator|=(perms & x , perms y) { x = x | y ; return x ; } inline perms & operator^=(perms & x , perms y) { x = x ^ y ; return x ; }
>
>
>
>
>
> class file_status
> {
> public:
> file_status() : m_value(status_error), m_perms(perms_not_known) {}
> explicit file_status(file_type v, perms prms = perms_not_known)
> : m_value(v), m_perms(prms) {}
>
>
> file_type type() const { return m_value; }
> perms permissions() const { return m_perms; }
>
>
> void type(file_type v) { m_value = v; }
> void permissions(perms prms) { m_perms = prms; }
>
> bool operator==(const file_status& rhs) const { return type() == rhs.type() &&
> permissions() == rhs.permissions(); }
> bool operator!=(const file_status& rhs) const { return !(*this == rhs); }
>
> private:
> file_type m_value;
> enum perms m_perms;
> };
>
> inline bool type_present(file_status f) { return f.type() != status_error; }
> inline bool permissions_present(file_status f)
> {return f.permissions() != perms_not_known;}
> inline bool status_known(file_status f) { return type_present(f) && permissions_present(f); }
> inline bool exists(file_status f) { return f.type() != status_error
> && f.type() != file_not_found; }
> inline bool is_regular_file(file_status f){ return f.type() == regular_file; }
> inline bool is_directory(file_status f) { return f.type() == directory_file; }
> inline bool is_symlink(file_status f) { return f.type() == symlink_file; }
> inline bool is_other(file_status f) { return exists(f) && !is_regular_file(f)
> && !is_directory(f) && !is_symlink(f); }
>
>
> inline bool is_regular(file_status f) { return f.type() == regular_file; }
>
>
> struct space_info
> {
>
> boost::uintmax_t capacity;
> boost::uintmax_t free;
> boost::uintmax_t available;
> };
>
> enum class copy_option
> {none, fail_if_exists = none, overwrite_if_exists};
> 
>
>
>
>
>
> namespace detail
> {
> 
> file_status status(const path&p, system::error_code* ec=0);
> 
> file_status symlink_status(const path& p, system::error_code* ec=0);
> 
> bool is_empty(const path& p, system::error_code* ec=0);
> 
> path initial_path(system::error_code* ec=0);
> 
> path canonical(const path& p, const path& base, system::error_code* ec=0);
> 
> void copy(const path& from, const path& to, system::error_code* ec=0);
> 
> void copy_directory(const path& from, const path& to, system::error_code* ec=0);
> 
> void copy_file(const path& from, const path& to,
> copy_option option,
> system::error_code* ec=0);
> 
> void copy_symlink(const path& existing_symlink, const path& new_symlink, system::error_code* ec=0);
> 
> bool create_directories(const path& p, system::error_code* ec=0);
> 
> bool create_directory(const path& p, system::error_code* ec=0);
> 
> void create_directory_symlink(const path& to, const path& from,
> system::error_code* ec=0);
> 
> void create_hard_link(const path& to, const path& from, system::error_code* ec=0);
> 
> void create_symlink(const path& to, const path& from, system::error_code* ec=0);
> 
> path current_path(system::error_code* ec=0);
> 
> void current_path(const path& p, system::error_code* ec=0);
> 
> bool equivalent(const path& p1, const path& p2, system::error_code* ec=0);
> 
> boost::uintmax_t file_size(const path& p, system::error_code* ec=0);
> 
> boost::uintmax_t hard_link_count(const path& p, system::error_code* ec=0);
> 
> std::time_t last_write_time(const path& p, system::error_code* ec=0);
> 
> void last_write_time(const path& p, const std::time_t new_time,
> system::error_code* ec=0);
> 
> void permissions(const path& p, perms prms, system::error_code* ec=0);
> 
> path read_symlink(const path& p, system::error_code* ec=0);
> 
>
> bool remove(const path& p, system::error_code* ec=0);
> 
> boost::uintmax_t remove_all(const path& p, system::error_code* ec=0);
> 
> void rename(const path& old_p, const path& new_p, system::error_code* ec=0);
> 
> void resize_file(const path& p, uintmax_t size, system::error_code* ec=0);
> 
> space_info space(const path& p, system::error_code* ec=0);
> 
> path system_complete(const path& p, system::error_code* ec=0);
> 
> path temp_directory_path(system::error_code* ec=0);
> 
> path unique_path(const path& p, system::error_code* ec=0);
> }
>
>
>
>
>
>
>
> inline
> file_status status(const path& p) {return detail::status(p);}
> inline
> file_status status(const path& p, system::error_code& ec)
> {return detail::status(p, &ec);}
> inline
> file_status symlink_status(const path& p) {return detail::symlink_status(p);}
> inline
> file_status symlink_status(const path& p, system::error_code& ec)
> {return detail::symlink_status(p, &ec);}
> inline
> bool exists(const path& p) {return exists(detail::status(p));}
> inline
> bool exists(const path& p, system::error_code& ec)
> {return exists(detail::status(p, &ec));}
> inline
> bool is_directory(const path& p) {return is_directory(detail::status(p));}
> inline
> bool is_directory(const path& p, system::error_code& ec)
> {return is_directory(detail::status(p, &ec));}
> inline
> bool is_regular_file(const path& p) {return is_regular_file(detail::status(p));}
> inline
> bool is_regular_file(const path& p, system::error_code& ec)
> {return is_regular_file(detail::status(p, &ec));}
> inline
> bool is_other(const path& p) {return is_other(detail::status(p));}
> inline
> bool is_other(const path& p, system::error_code& ec)
> {return is_other(detail::status(p, &ec));}
> inline
> bool is_symlink(const path& p) {return is_symlink(detail::symlink_status(p));}
> inline
> bool is_symlink(const path& p, system::error_code& ec)
> {return is_symlink(detail::symlink_status(p, &ec));}
>
> inline
> bool is_regular(const path& p) {return is_regular(detail::status(p));}
> inline
> bool is_regular(const path& p, system::error_code& ec)
> {return is_regular(detail::status(p, &ec));}
>
>
> inline
> bool is_empty(const path& p) {return detail::is_empty(p);}
> inline
> bool is_empty(const path& p, system::error_code& ec)
> {return detail::is_empty(p, &ec);}
># 335 "/usr/include/boost/filesystem/operations.hpp" 3 4
> path current_path();
> path initial_path();
>
> 
> path absolute(const path& p, const path& base=current_path());
>
>
> inline
> path canonical(const path& p, const path& base=current_path())
> {return detail::canonical(p, base);}
> inline
> path canonical(const path& p, system::error_code& ec)
> {return detail::canonical(p, current_path(), &ec);}
> inline
> path canonical(const path& p, const path& base, system::error_code& ec)
> {return detail::canonical(p, base, &ec);}
>
>
> inline
> path complete(const path& p)
> {
> return absolute(p, initial_path());
> }
>
> inline
> path complete(const path& p, const path& base)
> {
> return absolute(p, base);
> }
>
>
> inline
> void copy(const path& from, const path& to) {detail::copy(from, to);}
>
> inline
> void copy(const path& from, const path& to, system::error_code& ec)
> {detail::copy(from, to, &ec);}
> inline
> void copy_directory(const path& from, const path& to)
> {detail::copy_directory(from, to);}
> inline
> void copy_directory(const path& from, const path& to, system::error_code& ec)
> {detail::copy_directory(from, to, &ec);}
> inline
> void copy_file(const path& from, const path& to,
> copy_option option)
> {detail::copy_file(from, to, option);}
> inline
> void copy_file(const path& from, const path& to)
> {detail::copy_file(from, to, copy_option::fail_if_exists);}
> inline
> void copy_file(const path& from, const path& to,
> copy_option option, system::error_code& ec)
> {detail::copy_file(from, to, option, &ec);}
> inline
> void copy_file(const path& from, const path& to, system::error_code& ec)
> {detail::copy_file(from, to, copy_option::fail_if_exists, &ec);}
> inline
> void copy_symlink(const path& existing_symlink, const path& new_symlink) {detail::copy_symlink(existing_symlink, new_symlink);}
>
> inline
> void copy_symlink(const path& existing_symlink, const path& new_symlink, system::error_code& ec)
> {detail::copy_symlink(existing_symlink, new_symlink, &ec);}
> inline
> bool create_directories(const path& p) {return detail::create_directories(p);}
>
> inline
> bool create_directories(const path& p, system::error_code& ec)
> {return detail::create_directories(p, &ec);}
> inline
> bool create_directory(const path& p) {return detail::create_directory(p);}
>
> inline
> bool create_directory(const path& p, system::error_code& ec)
> {return detail::create_directory(p, &ec);}
> inline
> void create_directory_symlink(const path& to, const path& from)
> {detail::create_directory_symlink(to, from);}
> inline
> void create_directory_symlink(const path& to, const path& from, system::error_code& ec)
> {detail::create_directory_symlink(to, from, &ec);}
> inline
> void create_hard_link(const path& to, const path& new_hard_link) {detail::create_hard_link(to, new_hard_link);}
>
> inline
> void create_hard_link(const path& to, const path& new_hard_link, system::error_code& ec)
> {detail::create_hard_link(to, new_hard_link, &ec);}
> inline
> void create_symlink(const path& to, const path& new_symlink) {detail::create_symlink(to, new_symlink);}
>
> inline
> void create_symlink(const path& to, const path& new_symlink, system::error_code& ec)
> {detail::create_symlink(to, new_symlink, &ec);}
> inline
> path current_path() {return detail::current_path();}
>
> inline
> path current_path(system::error_code& ec) {return detail::current_path(&ec);}
>
> inline
> void current_path(const path& p) {detail::current_path(p);}
>
> inline
> void current_path(const path& p, system::error_code& ec) {detail::current_path(p, &ec);}
>
> inline
> bool equivalent(const path& p1, const path& p2) {return detail::equivalent(p1, p2);}
>
> inline
> bool equivalent(const path& p1, const path& p2, system::error_code& ec)
> {return detail::equivalent(p1, p2, &ec);}
> inline
> boost::uintmax_t file_size(const path& p) {return detail::file_size(p);}
>
> inline
> boost::uintmax_t file_size(const path& p, system::error_code& ec)
> {return detail::file_size(p, &ec);}
> inline
> boost::uintmax_t hard_link_count(const path& p) {return detail::hard_link_count(p);}
>
> inline
> boost::uintmax_t hard_link_count(const path& p, system::error_code& ec)
> {return detail::hard_link_count(p, &ec);}
> inline
> path initial_path() {return detail::initial_path();}
>
> inline
> path initial_path(system::error_code& ec) {return detail::initial_path(&ec);}
>
> template <class Path>
> path initial_path() {return initial_path();}
> template <class Path>
> path initial_path(system::error_code& ec) {return detail::initial_path(&ec);}
>
> inline
> std::time_t last_write_time(const path& p) {return detail::last_write_time(p);}
>
> inline
> std::time_t last_write_time(const path& p, system::error_code& ec)
> {return detail::last_write_time(p, &ec);}
> inline
> void last_write_time(const path& p, const std::time_t new_time)
> {detail::last_write_time(p, new_time);}
> inline
> void last_write_time(const path& p, const std::time_t new_time, system::error_code& ec)
> {detail::last_write_time(p, new_time, &ec);}
> inline
> void permissions(const path& p, perms prms)
> {detail::permissions(p, prms);}
> inline
> void permissions(const path& p, perms prms, system::error_code& ec)
> {detail::permissions(p, prms, &ec);}
>
> inline
> path read_symlink(const path& p) {return detail::read_symlink(p);}
>
> inline
> path read_symlink(const path& p, system::error_code& ec)
> {return detail::read_symlink(p, &ec);}
> inline
>
> bool remove(const path& p) {return detail::remove(p);}
>
> inline
> bool remove(const path& p, system::error_code& ec) {return detail::remove(p, &ec);}
>
> inline
> boost::uintmax_t remove_all(const path& p) {return detail::remove_all(p);}
>
> inline
> boost::uintmax_t remove_all(const path& p, system::error_code& ec)
> {return detail::remove_all(p, &ec);}
> inline
> void rename(const path& old_p, const path& new_p) {detail::rename(old_p, new_p);}
>
> inline
> void rename(const path& old_p, const path& new_p, system::error_code& ec)
> {detail::rename(old_p, new_p, &ec);}
> inline
> void resize_file(const path& p, uintmax_t size) {detail::resize_file(p, size);}
>
> inline
> void resize_file(const path& p, uintmax_t size, system::error_code& ec)
> {detail::resize_file(p, size, &ec);}
> inline
> space_info space(const path& p) {return detail::space(p);}
>
> inline
> space_info space(const path& p, system::error_code& ec) {return detail::space(p, &ec);}
>
>
> inline bool symbolic_link_exists(const path& p)
> { return is_symlink(symlink_status(p)); }
>
>
> inline
> path system_complete(const path& p) {return detail::system_complete(p);}
>
> inline
> path system_complete(const path& p, system::error_code& ec)
> {return detail::system_complete(p, &ec);}
> inline
> path temp_directory_path() {return detail::temp_directory_path();}
>
> inline
> path temp_directory_path(system::error_code& ec)
> {return detail::temp_directory_path(&ec);}
> inline
> path unique_path(const path& p="%%%%-%%%%-%%%%-%%%%")
> { return detail::unique_path(p); }
> inline
> path unique_path(const path& p, system::error_code& ec)
> { return detail::unique_path(p, &ec); }
># 559 "/usr/include/boost/filesystem/operations.hpp" 3 4
>class directory_entry
>{
>public:
>
>
>
> directory_entry() {}
> explicit directory_entry(const boost::filesystem::path& p,
> file_status st = file_status(), file_status symlink_st=file_status())
> : m_path(p), m_status(st), m_symlink_status(symlink_st)
> {}
>
> void assign(const boost::filesystem::path& p,
> file_status st = file_status(), file_status symlink_st = file_status())
> { m_path = p; m_status = st; m_symlink_status = symlink_st; }
>
> void replace_filename(const boost::filesystem::path& p,
> file_status st = file_status(), file_status symlink_st = file_status())
> {
> m_path.remove_filename();
> m_path /= p;
> m_status = st;
> m_symlink_status = symlink_st;
> }
>
>
> void replace_leaf(const boost::filesystem::path& p,
> file_status st, file_status symlink_st)
> { replace_filename(p, st, symlink_st); }
>
>
> const boost::filesystem::path& path() const {return m_path;}
> file_status status() const {return m_get_status();}
> file_status status(system::error_code& ec) const {return m_get_status(&ec);}
> file_status symlink_status() const {return m_get_symlink_status();}
> file_status symlink_status(system::error_code& ec) const {return m_get_symlink_status(&ec);}
>
> bool operator==(const directory_entry& rhs) {return m_path == rhs.m_path;}
> bool operator!=(const directory_entry& rhs) {return m_path != rhs.m_path;}
> bool operator< (const directory_entry& rhs) {return m_path < rhs.m_path;}
> bool operator<=(const directory_entry& rhs) {return m_path <= rhs.m_path;}
> bool operator> (const directory_entry& rhs) {return m_path > rhs.m_path;}
> bool operator>=(const directory_entry& rhs) {return m_path >= rhs.m_path;}
>
>private:
> boost::filesystem::path m_path;
> mutable file_status m_status;
> mutable file_status m_symlink_status;
>
> file_status m_get_status(system::error_code* ec=0) const;
> file_status m_get_symlink_status(system::error_code* ec=0) const;
>};
>
>
>
>
>
>
>
>class directory_iterator;
>
>namespace detail
>{
> 
> system::error_code dir_itr_close(
> void *& handle
>
> , void *& buffer
>
> );
>
> struct dir_itr_imp
> {
> directory_entry dir_entry;
> void* handle;
>
>
> void* buffer;
>
>
> dir_itr_imp() : handle(0)
>
> , buffer(0)
>
> {}
>
> ~dir_itr_imp()
> {
> dir_itr_close(handle
>
> , buffer
>
> );
> }
> };
>
>
> void directory_iterator_construct(directory_iterator& it,
> const path& p, system::error_code* ec);
> void directory_iterator_increment(directory_iterator& it,
> system::error_code* ec);
>
>}
>
>
>
>
>
>
>
> class directory_iterator
> : public boost::iterator_facade< directory_iterator,
> directory_entry,
> boost::single_pass_traversal_tag >
> {
> public:
>
> directory_iterator(){}
>
>
>
> explicit directory_iterator(const path& p)
> : m_imp(new detail::dir_itr_imp)
> { detail::directory_iterator_construct(*this, p, 0); }
>
> directory_iterator(const path& p, system::error_code& ec)
> : m_imp(new detail::dir_itr_imp)
> { detail::directory_iterator_construct(*this, p, &ec); }
>
> ~directory_iterator() {}
>
> directory_iterator& increment(system::error_code& ec)
> {
> detail::directory_iterator_increment(*this, &ec);
> return *this;
> }
>
> private:
> friend struct detail::dir_itr_imp;
> friend void detail::directory_iterator_construct(directory_iterator& it,
> const path& p, system::error_code* ec);
> friend void detail::directory_iterator_increment(directory_iterator& it,
> system::error_code* ec);
>
>
>
> boost::shared_ptr< detail::dir_itr_imp > m_imp;
>
> friend class boost::iterator_core_access;
>
> boost::iterator_facade<
> directory_iterator,
> directory_entry,
> boost::single_pass_traversal_tag >::reference dereference() const
> {
> ((void)0);
> return m_imp->dir_entry;
> }
>
> void increment() { detail::directory_iterator_increment(*this, 0); }
>
> bool equal(const directory_iterator& rhs) const
> { return m_imp == rhs.m_imp; }
> };
>
>
>
>
>
>
>
> enum class symlink_option
> {
> none,
> no_recurse = none,
> recurse,
> _detail_no_push = recurse << 1
> };
> 
>
> inline symlink_option operator| (symlink_option x , symlink_option y ) { return static_cast<symlink_option>( static_cast<boost::int_least32_t>(x) | static_cast<boost::int_least32_t>(y)); } inline symlink_option operator& (symlink_option x , symlink_option y ) { return static_cast<symlink_option>( static_cast<boost::int_least32_t>(x) & static_cast<boost::int_least32_t>(y)); } inline symlink_option operator^ (symlink_option x , symlink_option y ) { return static_cast<symlink_option>( static_cast<boost::int_least32_t>(x) ^ static_cast<boost::int_least32_t>(y)); } inline symlink_option operator~ (symlink_option x ) { return static_cast<symlink_option>(~static_cast<boost::int_least32_t>(x)); } inline symlink_option & operator&=(symlink_option & x , symlink_option y) { x = x & y ; return x ; } inline symlink_option & operator|=(symlink_option & x , symlink_option y) { x = x | y ; return x ; } inline symlink_option & operator^=(symlink_option & x , symlink_option y) { x = x ^ y ; return x ; }
>
> namespace detail
> {
> struct recur_dir_itr_imp
> {
> typedef directory_iterator element_type;
> std::stack< element_type, std::vector< element_type > > m_stack;
> int m_level;
> symlink_option m_options;
>
> recur_dir_itr_imp() : m_level(0), m_options(symlink_option::none) {}
>
> void increment(system::error_code* ec);
>
> void pop();
>
> };
>
>
>
>
>
> inline
> void recur_dir_itr_imp::increment(system::error_code* ec)
>
> {
> if ((m_options & symlink_option::_detail_no_push) == symlink_option::_detail_no_push)
> m_options &= ~symlink_option::_detail_no_push;
>
> else
> {
>
>
>
>
>
>
>
> bool or_pred = (m_options & symlink_option::recurse) == symlink_option::recurse
> || (ec == 0 ? !is_symlink(m_stack.top()->symlink_status())
> : !is_symlink(m_stack.top()->symlink_status(*ec)));
> if (ec != 0 && *ec)
> return;
> bool and_pred = or_pred && (ec == 0 ? is_directory(m_stack.top()->status())
> : is_directory(m_stack.top()->status(*ec)));
> if (ec != 0 && *ec)
> return;
>
> if (and_pred)
> {
> if (ec == 0)
> m_stack.push(directory_iterator(m_stack.top()->path()));
> else
> {
> m_stack.push(directory_iterator(m_stack.top()->path(), *ec));
> if (*ec)
> return;
> }
> if (m_stack.top() != directory_iterator())
> {
> ++m_level;
> return;
> }
> m_stack.pop();
> }
> }
>
> while (!m_stack.empty() && ++m_stack.top() == directory_iterator())
> {
> m_stack.pop();
> --m_level;
> }
> }
>
> inline
> void recur_dir_itr_imp::pop()
> {
> ((void)0)
> ;
>
> do
> {
> m_stack.pop();
> --m_level;
> }
> while (!m_stack.empty() && ++m_stack.top() == directory_iterator());
> }
> }
>
>
>
>
>
>
>
> class recursive_directory_iterator
> : public boost::iterator_facade<
> recursive_directory_iterator,
> directory_entry,
> boost::single_pass_traversal_tag >
> {
> public:
>
> recursive_directory_iterator(){}
>
> explicit recursive_directory_iterator(const path& dir_path,
> symlink_option opt = symlink_option::none)
> : m_imp(new detail::recur_dir_itr_imp)
> {
> m_imp->m_options = opt;
> m_imp->m_stack.push(directory_iterator(dir_path));
> if (m_imp->m_stack.top() == directory_iterator())
> { m_imp.reset (); }
> }
>
> recursive_directory_iterator(const path& dir_path,
> symlink_option opt,
> system::error_code & ec)
> : m_imp(new detail::recur_dir_itr_imp)
> {
> m_imp->m_options = opt;
> m_imp->m_stack.push(directory_iterator(dir_path, ec));
> if (m_imp->m_stack.top() == directory_iterator())
> { m_imp.reset (); }
> }
>
> recursive_directory_iterator(const path& dir_path,
> system::error_code & ec)
> : m_imp(new detail::recur_dir_itr_imp)
> {
> m_imp->m_options = symlink_option::none;
> m_imp->m_stack.push(directory_iterator(dir_path, ec));
> if (m_imp->m_stack.top() == directory_iterator())
> { m_imp.reset (); }
> }
>
> recursive_directory_iterator& increment(system::error_code& ec)
> {
> ((void)0)
> ;
> m_imp->increment(&ec);
> if (m_imp->m_stack.empty())
> m_imp.reset();
> return *this;
> }
>
> int level() const
> {
> ((void)0)
> ;
> return m_imp->m_level;
> }
>
> bool no_push_pending() const
> {
> ((void)0)
> ;
> return (m_imp->m_options & symlink_option::_detail_no_push)
> == symlink_option::_detail_no_push;
> }
>
>
> bool no_push_request() const { return no_push_pending(); }
>
>
> void pop()
> {
> ((void)0)
> ;
> m_imp->pop();
> if (m_imp->m_stack.empty()) m_imp.reset();
> }
>
> void no_push(bool value=true)
> {
> ((void)0)
> ;
> if (value)
> m_imp->m_options |= symlink_option::_detail_no_push;
> else
> m_imp->m_options &= ~symlink_option::_detail_no_push;
> }
>
> file_status status() const
> {
> ((void)0)
> ;
> return m_imp->m_stack.top()->status();
> }
>
> file_status symlink_status() const
> {
> ((void)0)
> ;
> return m_imp->m_stack.top()->symlink_status();
> }
>
> private:
>
>
>
> boost::shared_ptr< detail::recur_dir_itr_imp > m_imp;
>
> friend class boost::iterator_core_access;
>
> boost::iterator_facade<
> recursive_directory_iterator,
> directory_entry,
> boost::single_pass_traversal_tag >::reference
> dereference() const
> {
> ((void)0)
> ;
> return *m_imp->m_stack.top();
> }
>
> void increment()
> {
> ((void)0)
> ;
> m_imp->increment(0);
> if (m_imp->m_stack.empty())
> m_imp.reset();
> }
>
> bool equal(const recursive_directory_iterator& rhs) const
> { return m_imp == rhs.m_imp; }
>
> };
>
>
> typedef recursive_directory_iterator wrecursive_directory_iterator;
># 980 "/usr/include/boost/filesystem/operations.hpp" 3 4
> class __attribute__((__visibility__("default"))) filesystem_error : public system::system_error
> {
>
>
>
>
> public:
>
>
> filesystem_error(
> const std::string & what_arg, system::error_code ec)
> : system::system_error(ec, what_arg)
> {
> try
> {
> m_imp_ptr.reset(new m_imp);
> }
> catch (...) { m_imp_ptr.reset(); }
> }
>
> filesystem_error(
> const std::string & what_arg, const path& path1_arg,
> system::error_code ec)
> : system::system_error(ec, what_arg)
> {
> try
> {
> m_imp_ptr.reset(new m_imp);
> m_imp_ptr->m_path1 = path1_arg;
> }
> catch (...) { m_imp_ptr.reset(); }
> }
>
> filesystem_error(
> const std::string & what_arg, const path& path1_arg,
> const path& path2_arg, system::error_code ec)
> : system::system_error(ec, what_arg)
> {
> try
> {
> m_imp_ptr.reset(new m_imp);
> m_imp_ptr->m_path1 = path1_arg;
> m_imp_ptr->m_path2 = path2_arg;
> }
> catch (...) { m_imp_ptr.reset(); }
> }
>
> ~filesystem_error() throw() {}
>
> const path& path1() const
> {
> static const path empty_path;
> return m_imp_ptr.get() ? m_imp_ptr->m_path1 : empty_path ;
> }
> const path& path2() const
> {
> static const path empty_path;
> return m_imp_ptr.get() ? m_imp_ptr->m_path2 : empty_path ;
> }
>
> const char* what() const throw()
> {
> if (!m_imp_ptr.get())
> return system::system_error::what();
>
> try
> {
> if (m_imp_ptr->m_what.empty())
> {
> m_imp_ptr->m_what = system::system_error::what();
> if (!m_imp_ptr->m_path1.empty())
> {
> m_imp_ptr->m_what += ": \"";
> m_imp_ptr->m_what += m_imp_ptr->m_path1.string();
> m_imp_ptr->m_what += "\"";
> }
> if (!m_imp_ptr->m_path2.empty())
> {
> m_imp_ptr->m_what += ", \"";
> m_imp_ptr->m_what += m_imp_ptr->m_path2.string();
> m_imp_ptr->m_what += "\"";
> }
> }
> return m_imp_ptr->m_what.c_str();
> }
> catch (...)
> {
> return system::system_error::what();
> }
> }
>
> private:
> struct m_imp
> {
> path m_path1;
> path m_path2;
> std::string m_what;
> };
> boost::shared_ptr<m_imp> m_imp_ptr;
> };
>
>
>
>
>
>
>
> namespace detail
> {
> bool possible_large_file_size_support();
> }
>
> }
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 1096 "/usr/include/boost/filesystem/operations.hpp" 2 3 4
># 18 "/usr/include/boost/filesystem.hpp" 2 3 4
># 1 "/usr/include/boost/filesystem/convenience.hpp" 1 3 4
># 25 "/usr/include/boost/filesystem/convenience.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 26 "/usr/include/boost/filesystem/convenience.hpp" 2 3 4
>
>namespace boost
>{
> namespace filesystem
> {
>
>
>
> inline std::string extension(const path & p)
> {
> return p.extension().string();
> }
>
> inline std::string basename(const path & p)
> {
> return p.stem().string();
> }
>
> inline path change_extension( const path & p, const path & new_extension )
> {
> path new_p( p );
> new_p.replace_extension( new_extension );
> return new_p;
> }
>
>
>
>
> }
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 58 "/usr/include/boost/filesystem/convenience.hpp" 2 3 4
># 19 "/usr/include/boost/filesystem.hpp" 2 3 4
># 17 "../src/file.h" 2
>
>
>
>
>
>
>typedef std::complex<double> cplx;
>
>
>
>class carefulScanData;
>
>struct fileData
>{
>public:
> std::string *timeStamp;
> const char *fileName;
> const double *code;
> const double *rawData;
> const cplx *corr;
> const double *rawDeconvolution;
> const double *correctedDeconvolution;
> double detectionReferenceValue;
> uint32_t dataLength;
> uint32_t deconvolutionLength;
> uint32_t maxDetectionPoints;
> uint32_t deconvolutionZeroPoint;
> pointData point;
> double timeStep;
> double freqStep;
>};
>
>fileData *fillInFileData(wildfireStatus &stats, measurementSettings &settings, const char *fileName, pointData *pd = 0);
>
>
>
>bool writeBigFile(fileData *dat, wildfireStatus stat);
>
>
>
>struct dataFileData
>{
> std::string basefileName;
> time_t date;
>};
>
>typedef std::list<dataFileData> dataFileList;
>
>using boost::filesystem::path;
>
>bool dataFileCompare(dataFileData df1, dataFileData df2);
>bool dataFileEqual(dataFileData df1, dataFileData df2);
>std::string getBaseNameFromPath(path p);
>time_t getTimeFromBasefileName(std::string n);
>path getDataFilePathFromBaseFileName(std::string n);
>path getCompressedFilePathFromBaseFileName(std::string n);
>path getImageFilePathFromBaseFileName(std::string n);
>double getDiskFreeSpace();
>dataFileList *getAllDataFiles();
>
>
>
>const double standardFreeSpace = 10.0;
>const double standardFreeSpaceLow = 20.0;
>const double seriousFreeSpace = 3.0;
>const double seriousFreeSpaceLow = 10.0;
>
>
>namespace sf
>{
> const uint32_t fileFormatRevision = 2;
> const uint32_t maximumRecognisedFileFormatRevision = 2;
>
> const std::string defaulSaveStateFilename("iwf_state.iwf");
>
> const std::string fileHeader("iwf system state file.");
> const std::string revisionHeader("%rev");
> const std::string systemHeader("%sys");
> const std::string globalsHeader("%glo");
> const std::string filtersHeader("%fil");
> const std::string alarmsHeader("%alm");
> const std::string pointsHeader("%pnt");
> const std::string arrayHeader("%arr");
> const std::string passwordHeader("%pas");
>
> const std::string revisionName("iwf revision# ");
> const std::string fileFormatRevisionName("Filetype revision# ");
> const std::string sysDataSizeName("System data size# ");
> const std::string horizSensorName("Horizontal sensor position# ");
> const std::string vertSensorName("Vertical sensor position# ");
> const std::string startPosName("Scan start position# ");
> const std::string endPosName("Scan stop position# ");
> const std::string stepName("Scan step size# ");
> const std::string powerName("Power# ");
> const std::string repeatsName("Repeats# ");
> const std::string detectRatioName("Detection ratio# ");
> const std::string alarmRatioName("Alarm ratio# ");
> const std::string gainName("Gain# ");
> const std::string bandwidthName("Bandwidth# ");
> const std::string maxAltName("Max altitude# ");
> const std::string minAltName("Min altitude# ");
> const std::string debugName("debug level# ");
> const std::string corrOffsetName("correction offset# ");
> const std::string maxDetectName("maximum detection distance# ");
> const std::string minDetectName("minimum detection distance# ");
> const std::string maxCorrectName("maximum correction distance# ");
> const std::string maxDeconvName("maximum deconvolution distance# ");
> const std::string minCorrName("minimum correction adjustment# ");
> const std::string filterCountName("Filter count# ");
> const std::string filterNumberName("Filter number# ");
> const std::string decimationName("Filter decimation# ");
> const std::string alarmCountName("Unacknowledged alarm count# ");
> const std::string alarmDataName("Alarm data# ");
> const std::string arrayCountName("Point array count# ");
> const std::string arrayNameName("Array name# ");
> const std::string arrayValidityName("Array validity conditions# ");
> const std::string pointCountName("Point count# ");
> const std::string pointHeader("ID, Position(h, v), use, detect ratio, alarm ratio, repeats, gain, bandwidth, power, k, Dmax, Dmin, Cmax, DDmax, Cmin# ");
>
> const std::string defaultArrayName("Default");
> const std::string defaultValidityName("Default");
> const std::string boolFalseString("false");
> const std::string boolTrueString("true");
> const std::string boolNoString("no");
>}
>
>
>
>bool saveState(const std::string &fileName,const wildfireStatus &stats, const measurementSettings &settings);
>bool loadState(const std::string &fileName, wildfireStatus &stats, measurementSettings &settings);
>
>
>
>bool readFromState(uint32_t what, std::string &fileName);
>std::string boolToString(bool in);
>bool readBool(std::istream &file);
>
>std::string *readSystemID();
># 21 "../src/target.h" 2
>
>
>
># 1 "/usr/include/boost/property_tree/ptree.hpp" 1 3 4
># 15 "/usr/include/boost/property_tree/ptree.hpp" 3 4
># 1 "/usr/include/boost/property_tree/ptree_fwd.hpp" 1 3 4
># 15 "/usr/include/boost/property_tree/ptree_fwd.hpp" 3 4
># 1 "/usr/include/boost/optional/optional_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/optional/optional_fwd.hpp" 3 4
>namespace boost {
>
>template<class T> class optional ;
>
>template<class T> void swap ( optional<T>& , optional<T>& ) ;
>
>template<class T> struct optional_swap_should_use_default_constructor ;
>
>}
># 16 "/usr/include/boost/property_tree/ptree_fwd.hpp" 2 3 4
>
>
>
>
>
>namespace boost { namespace property_tree
>{
> namespace detail {
> template <typename T> struct less_nocase;
> }
>
>
>
> template < class Key, class Data, class KeyCompare = std::less<Key> >
> class basic_ptree;
>
> template <typename T>
> struct id_translator;
>
> template <typename String, typename Translator>
> class string_path;
># 72 "/usr/include/boost/property_tree/ptree_fwd.hpp" 3 4
> template <typename Key>
> struct path_of;
>
>
>
>
>
> template <typename Internal, typename External>
> struct translator_between;
>
> class ptree_error;
> class ptree_bad_data;
> class ptree_bad_path;
>
>
>
>
> typedef string_path<std::string, id_translator<std::string> > path;
>
>
>
>
>
> typedef basic_ptree<std::string, std::string> ptree;
>
>
>
>
>
> typedef basic_ptree<std::string, std::string,
> detail::less_nocase<std::string> >
> iptree;
>
>
>
> typedef string_path<std::wstring, id_translator<std::wstring> > wpath;
>
>
>
>
>
>
> typedef basic_ptree<std::wstring, std::wstring> wptree;
>
>
>
>
>
>
> typedef basic_ptree<std::wstring, std::wstring,
> detail::less_nocase<std::wstring> >
> wiptree;
>
>
>
>
>
>
>
> template<class K, class D, class C>
> void swap(basic_ptree<K, D, C> &pt1,
> basic_ptree<K, D, C> &pt2);
>
>} }
># 16 "/usr/include/boost/property_tree/ptree.hpp" 2 3 4
># 1 "/usr/include/boost/property_tree/string_path.hpp" 1 3 4
># 15 "/usr/include/boost/property_tree/string_path.hpp" 3 4
># 1 "/usr/include/boost/property_tree/id_translator.hpp" 1 3 4
># 16 "/usr/include/boost/property_tree/id_translator.hpp" 3 4
># 1 "/usr/include/boost/optional.hpp" 1 3 4
># 15 "/usr/include/boost/optional.hpp" 3 4
># 1 "/usr/include/boost/optional/optional.hpp" 1 3 4
># 22 "/usr/include/boost/optional/optional.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 23 "/usr/include/boost/optional/optional.hpp" 2 3 4
># 32 "/usr/include/boost/optional/optional.hpp" 3 4
># 1 "/usr/include/boost/detail/reference_content.hpp" 1 3 4
># 28 "/usr/include/boost/detail/reference_content.hpp" 3 4
>namespace boost {
>
>namespace detail {
>
>
>
>
>
>
>template <typename RefT>
>class reference_content
>{
>private:
>
> RefT content_;
>
>public:
>
> ~reference_content()
> {
> }
>
> reference_content(RefT r)
> : content_( r )
> {
> }
>
> reference_content(const reference_content& operand)
> : content_( operand.content_ )
> {
> }
>
>private:
>
> reference_content& operator=(const reference_content&);
>
>public:
>
> RefT get() const
> {
> return content_;
> }
>
>};
>
>
>
>
>
>
>
>template <typename T = mpl::void_> struct make_reference_content;
>
>
>
>template <typename T>
>struct make_reference_content
>{
> typedef T type;
>};
>
>template <typename T>
>struct make_reference_content< T& >
>{
> typedef reference_content<T&> type;
>};
># 109 "/usr/include/boost/detail/reference_content.hpp" 3 4
>template <>
>struct make_reference_content< mpl::void_ >
>{
> template <typename T>
> struct apply
> : make_reference_content<T>
> {
> };
>
> typedef mpl::void_ type;
>};
>
>}
>
>
>
>
>
>
>
>template <typename T>
>struct has_nothrow_copy<
> ::boost::detail::reference_content< T& >
> >
> : mpl::true_
>{
>};
>
>
>
>}
># 33 "/usr/include/boost/optional/optional.hpp" 2 3 4
># 1 "/usr/include/boost/none.hpp" 1 3 4
># 15 "/usr/include/boost/none.hpp" 3 4
># 1 "/usr/include/boost/none_t.hpp" 1 3 4
># 15 "/usr/include/boost/none_t.hpp" 3 4
>namespace boost {
>
>namespace detail { struct none_helper{}; }
>
>typedef int detail::none_helper::*none_t ;
>
>}
># 16 "/usr/include/boost/none.hpp" 2 3 4
>
>
>
>
>
>namespace boost {
>
>none_t const none = (static_cast<none_t>(0)) ;
>
>}
># 34 "/usr/include/boost/optional/optional.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/utility/compare_pointees.hpp" 1 3 4
># 17 "/usr/include/boost/utility/compare_pointees.hpp" 3 4
>namespace boost {
># 28 "/usr/include/boost/utility/compare_pointees.hpp" 3 4
>template<class OptionalPointee>
>inline
>bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y )
>{
> return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ;
>}
>
>template<class OptionalPointee>
>struct equal_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
>{
> bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
> { return equal_pointees(x,y) ; }
>} ;
># 51 "/usr/include/boost/utility/compare_pointees.hpp" 3 4
>template<class OptionalPointee>
>inline
>bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y )
>{
> return !y ? false : ( !x ? true : (*x) < (*y) ) ;
>}
>
>template<class OptionalPointee>
>struct less_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
>{
> bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
> { return less_pointees(x,y) ; }
>} ;
>
>}
># 37 "/usr/include/boost/optional/optional.hpp" 2 3 4
># 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
># 16 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
># 1 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 1 3 4
># 17 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 18 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/preprocessor/punctuation/paren.hpp" 1 3 4
># 21 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/iteration/iterate.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/iteration/iterate.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/slot/slot.hpp" 1 3 4
># 16 "/usr/include/boost/preprocessor/slot/slot.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/slot/detail/def.hpp" 1 3 4
># 17 "/usr/include/boost/preprocessor/slot/slot.hpp" 2 3 4
># 21 "/usr/include/boost/preprocessor/iteration/iterate.hpp" 2 3 4
># 22 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 2 3 4
>
># 1 "/usr/include/boost/preprocessor/repetition/enum.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/repetition/enum.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/repetition/enum.hpp" 2 3 4
># 24 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 2 3 4
>
># 1 "/usr/include/boost/preprocessor/repetition/enum_binary_params.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 2 3 4
># 17 "/usr/include/boost/utility/in_place_factory.hpp" 2 3 4
>
>namespace boost {
>
>class in_place_factory_base {} ;
>
>
>
># 1 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
># 17 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
># 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
># 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
># 18 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
># 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
># 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
># 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
># 20 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
># 47 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
># 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
># 37 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
>class in_place_factory0
> :
> public in_place_factory_base
>{
>public:
>
> explicit in_place_factory0
> ( )
>
>
>
> {}
>
> template<class T>
> void* apply(void* address
> ) const
> {
> return new(address) T( );
> }
>
> template<class T>
> void* apply(void* address, std::size_t n
> ) const
> {
> for(char* next = address = this->template apply<T>(address);
> !! --n;)
> this->template apply<T>(next = next+sizeof(T));
> return address;
> }
>
> 
>};
># 79 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
>inline in_place_factory0 in_place()
>{
> return in_place_factory0();
>}
># 48 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
># 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
>template< class A0 >
>
>class in_place_factory1
> :
> public in_place_factory_base
>{
>public:
>
> explicit in_place_factory1
> ( A0 const& a0 )
>
> : m_a0 ( a0 )
>
> {}
>
> template<class T>
> void* apply(void* address
> ) const
> {
> return new(address) T( m_a0 );
> }
>
> template<class T>
> void* apply(void* address, std::size_t n
> ) const
> {
> for(char* next = address = this->template apply<T>(address);
> !! --n;)
> this->template apply<T>(next = next+sizeof(T));
> return address;
> }
>
> A0 const& m_a0;
>};
>
>
>template< class A0 >
>inline in_place_factory1< A0 >
>in_place( A0 const& a0 )
>{
> return in_place_factory1< A0 >
> ( a0 );
>}
># 53 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
># 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
>template< class A0 , class A1 >
>
>class in_place_factory2
> :
> public in_place_factory_base
>{
>public:
>
> explicit in_place_factory2
> ( A0 const& a0 , A1 const& a1 )
>
> : m_a0 ( a0 ) , m_a1 ( a1 )
>
> {}
>
> template<class T>
> void* apply(void* address
> ) const
> {
> return new(address) T( m_a0 , m_a1 );
> }
>
> template<class T>
> void* apply(void* address, std::size_t n
> ) const
> {
> for(char* next = address = this->template apply<T>(address);
> !! --n;)
> this->template apply<T>(next = next+sizeof(T));
> return address;
> }
>
> A0 const& m_a0; A1 const& m_a1;
>};
>
>
>template< class A0 , class A1 >
>inline in_place_factory2< A0 , A1 >
>in_place( A0 const& a0 , A1 const& a1 )
>{
> return in_place_factory2< A0 , A1 >
> ( a0 , a1 );
>}
># 58 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
># 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
>template< class A0 , class A1 , class A2 >
>
>class in_place_factory3
> :
> public in_place_factory_base
>{
>public:
>
> explicit in_place_factory3
> ( A0 const& a0 , A1 const& a1 , A2 const& a2 )
>
> : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 )
>
> {}
>
> template<class T>
> void* apply(void* address
> ) const
> {
> return new(address) T( m_a0 , m_a1 , m_a2 );
> }
>
> template<class T>
> void* apply(void* address, std::size_t n
> ) const
> {
> for(char* next = address = this->template apply<T>(address);
> !! --n;)
> this->template apply<T>(next = next+sizeof(T));
> return address;
> }
>
> A0 const& m_a0; A1 const& m_a1; A2 const& m_a2;
>};
>
>
>template< class A0 , class A1 , class A2 >
>inline in_place_factory3< A0 , A1 , A2 >
>in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 )
>{
> return in_place_factory3< A0 , A1 , A2 >
> ( a0 , a1 , a2 );
>}
># 63 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
># 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
>template< class A0 , class A1 , class A2 , class A3 >
>
>class in_place_factory4
> :
> public in_place_factory_base
>{
>public:
>
> explicit in_place_factory4
> ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 )
>
> : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 )
>
> {}
>
> template<class T>
> void* apply(void* address
> ) const
> {
> return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 );
> }
>
> template<class T>
> void* apply(void* address, std::size_t n
> ) const
> {
> for(char* next = address = this->template apply<T>(address);
> !! --n;)
> this->template apply<T>(next = next+sizeof(T));
> return address;
> }
>
> A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3;
>};
>
>
>template< class A0 , class A1 , class A2 , class A3 >
>inline in_place_factory4< A0 , A1 , A2 , A3 >
>in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 )
>{
> return in_place_factory4< A0 , A1 , A2 , A3 >
> ( a0 , a1 , a2 , a3 );
>}
># 68 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
># 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
>template< class A0 , class A1 , class A2 , class A3 , class A4 >
>
>class in_place_factory5
> :
> public in_place_factory_base
>{
>public:
>
> explicit in_place_factory5
> ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 )
>
> : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 )
>
> {}
>
> template<class T>
> void* apply(void* address
> ) const
> {
> return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 );
> }
>
> template<class T>
> void* apply(void* address, std::size_t n
> ) const
> {
> for(char* next = address = this->template apply<T>(address);
> !! --n;)
> this->template apply<T>(next = next+sizeof(T));
> return address;
> }
>
> A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4;
>};
>
>
>template< class A0 , class A1 , class A2 , class A3 , class A4 >
>inline in_place_factory5< A0 , A1 , A2 , A3 , A4 >
>in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 )
>{
> return in_place_factory5< A0 , A1 , A2 , A3 , A4 >
> ( a0 , a1 , a2 , a3 , a4 );
>}
># 73 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
># 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
>template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 >
>
>class in_place_factory6
> :
> public in_place_factory_base
>{
>public:
>
> explicit in_place_factory6
> ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 )
>
> : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 ) , m_a5 ( a5 )
>
> {}
>
> template<class T>
> void* apply(void* address
> ) const
> {
> return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 , m_a5 );
> }
>
> template<class T>
> void* apply(void* address, std::size_t n
> ) const
> {
> for(char* next = address = this->template apply<T>(address);
> !! --n;)
> this->template apply<T>(next = next+sizeof(T));
> return address;
> }
>
> A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4; A5 const& m_a5;
>};
>
>
>template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 >
>inline in_place_factory6< A0 , A1 , A2 , A3 , A4 , A5 >
>in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 )
>{
> return in_place_factory6< A0 , A1 , A2 , A3 , A4 , A5 >
> ( a0 , a1 , a2 , a3 , a4 , a5 );
>}
># 78 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
># 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
>template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 >
>
>class in_place_factory7
> :
> public in_place_factory_base
>{
>public:
>
> explicit in_place_factory7
> ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 )
>
> : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 ) , m_a5 ( a5 ) , m_a6 ( a6 )
>
> {}
>
> template<class T>
> void* apply(void* address
> ) const
> {
> return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 , m_a5 , m_a6 );
> }
>
> template<class T>
> void* apply(void* address, std::size_t n
> ) const
> {
> for(char* next = address = this->template apply<T>(address);
> !! --n;)
> this->template apply<T>(next = next+sizeof(T));
> return address;
> }
>
> A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4; A5 const& m_a5; A6 const& m_a6;
>};
>
>
>template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 >
>inline in_place_factory7< A0 , A1 , A2 , A3 , A4 , A5 , A6 >
>in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 )
>{
> return in_place_factory7< A0 , A1 , A2 , A3 , A4 , A5 , A6 >
> ( a0 , a1 , a2 , a3 , a4 , a5 , a6 );
>}
># 83 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
># 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
>template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 >
>
>class in_place_factory8
> :
> public in_place_factory_base
>{
>public:
>
> explicit in_place_factory8
> ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 )
>
> : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 ) , m_a5 ( a5 ) , m_a6 ( a6 ) , m_a7 ( a7 )
>
> {}
>
> template<class T>
> void* apply(void* address
> ) const
> {
> return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 , m_a5 , m_a6 , m_a7 );
> }
>
> template<class T>
> void* apply(void* address, std::size_t n
> ) const
> {
> for(char* next = address = this->template apply<T>(address);
> !! --n;)
> this->template apply<T>(next = next+sizeof(T));
> return address;
> }
>
> A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4; A5 const& m_a5; A6 const& m_a6; A7 const& m_a7;
>};
>
>
>template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 >
>inline in_place_factory8< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 >
>in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 )
>{
> return in_place_factory8< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 >
> ( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 );
>}
># 88 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
># 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
>template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 >
>
>class in_place_factory9
> :
> public in_place_factory_base
>{
>public:
>
> explicit in_place_factory9
> ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 )
>
> : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 ) , m_a5 ( a5 ) , m_a6 ( a6 ) , m_a7 ( a7 ) , m_a8 ( a8 )
>
> {}
>
> template<class T>
> void* apply(void* address
> ) const
> {
> return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 , m_a5 , m_a6 , m_a7 , m_a8 );
> }
>
> template<class T>
> void* apply(void* address, std::size_t n
> ) const
> {
> for(char* next = address = this->template apply<T>(address);
> !! --n;)
> this->template apply<T>(next = next+sizeof(T));
> return address;
> }
>
> A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4; A5 const& m_a5; A6 const& m_a6; A7 const& m_a7; A8 const& m_a8;
>};
>
>
>template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 >
>inline in_place_factory9< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >
>in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 )
>{
> return in_place_factory9< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >
> ( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 );
>}
># 93 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
># 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
>template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 >
>
>class in_place_factory10
> :
> public in_place_factory_base
>{
>public:
>
> explicit in_place_factory10
> ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 )
>
> : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 ) , m_a5 ( a5 ) , m_a6 ( a6 ) , m_a7 ( a7 ) , m_a8 ( a8 ) , m_a9 ( a9 )
>
> {}
>
> template<class T>
> void* apply(void* address
> ) const
> {
> return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 , m_a5 , m_a6 , m_a7 , m_a8 , m_a9 );
> }
>
> template<class T>
> void* apply(void* address, std::size_t n
> ) const
> {
> for(char* next = address = this->template apply<T>(address);
> !! --n;)
> this->template apply<T>(next = next+sizeof(T));
> return address;
> }
>
> A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4; A5 const& m_a5; A6 const& m_a6; A7 const& m_a7; A8 const& m_a8; A9 const& m_a9;
>};
>
>
>template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 >
>inline in_place_factory10< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >
>in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 )
>{
> return in_place_factory10< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >
> ( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 );
>}
># 98 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
># 25 "/usr/include/boost/utility/in_place_factory.hpp" 2 3 4
>
>}
>
># 1 "/usr/include/boost/utility/detail/in_place_factory_suffix.hpp" 1 3 4
># 29 "/usr/include/boost/utility/in_place_factory.hpp" 2 3 4
># 38 "/usr/include/boost/optional/optional.hpp" 2 3 4
># 99 "/usr/include/boost/optional/optional.hpp" 3 4
>namespace boost_optional_detail
>{
> template <class T, class Factory>
> inline void construct(Factory const& factory, void* address)
> {
> factory.template apply<T>(address);
> }
>}
>
>
>namespace boost {
>
>class in_place_factory_base ;
>class typed_in_place_factory_base ;
>
>
>template<class T> void swap ( optional<T>& x, optional<T>& y );
>
>namespace optional_detail {
>
>
>
>
>
>template <class T>
>class aligned_storage
>{
>
> union
>
>
> __attribute__((may_alias))
>
> dummy_u
> {
> char data[ sizeof(T) ];
> typename type_with_alignment<
> ::boost::alignment_of<T>::value >::type aligner_;
> } dummy_ ;
>
> public:
>
>
> void const* address() const { return &dummy_; }
> void * address() { return &dummy_; }
>
>
>
>
>} ;
>
>template<class T>
>struct types_when_isnt_ref
>{
> typedef T const& reference_const_type ;
> typedef T & reference_type ;
> typedef T const* pointer_const_type ;
> typedef T * pointer_type ;
> typedef T const& argument_type ;
>} ;
>template<class T>
>struct types_when_is_ref
>{
> typedef typename remove_reference<T>::type raw_type ;
>
> typedef raw_type& reference_const_type ;
> typedef raw_type& reference_type ;
> typedef raw_type* pointer_const_type ;
> typedef raw_type* pointer_type ;
> typedef raw_type& argument_type ;
>} ;
>
>struct optional_tag {} ;
>
>template<class T>
>class optional_base : public optional_tag
>{
> private :
>
> typedef
>
> typename
>
> ::boost::detail::make_reference_content<T>::type internal_type ;
>
> typedef aligned_storage<internal_type> storage_type ;
>
> typedef types_when_isnt_ref<T> types_when_not_ref ;
> typedef types_when_is_ref<T> types_when_ref ;
>
> typedef optional_base<T> this_type ;
>
> protected :
>
> typedef T value_type ;
>
> typedef mpl::true_ is_reference_tag ;
> typedef mpl::false_ is_not_reference_tag ;
>
> typedef typename is_reference<T>::type is_reference_predicate ;
>
> public:
> typedef typename mpl::if_<is_reference_predicate,types_when_ref,types_when_not_ref>::type types ;
>
> protected:
> typedef bool (this_type::*unspecified_bool_type)() const;
>
> typedef typename types::reference_type reference_type ;
> typedef typename types::reference_const_type reference_const_type ;
> typedef typename types::pointer_type pointer_type ;
> typedef typename types::pointer_const_type pointer_const_type ;
> typedef typename types::argument_type argument_type ;
>
>
>
> optional_base()
> :
> m_initialized(false) {}
>
>
>
> optional_base ( none_t )
> :
> m_initialized(false) {}
>
>
>
> optional_base ( argument_type val )
> :
> m_initialized(false)
> {
> construct(val);
> }
>
>
>
> optional_base ( bool cond, argument_type val )
> :
> m_initialized(false)
> {
> if ( cond )
> construct(val);
> }
>
>
>
> optional_base ( optional_base const& rhs )
> :
> m_initialized(false)
> {
> if ( rhs.is_initialized() )
> construct(rhs.get_impl());
> }
>
>
>
>
>
> template<class Expr>
> explicit optional_base ( Expr const& expr, Expr const* tag )
> :
> m_initialized(false)
> {
> construct(expr,tag);
> }
>
>
>
>
> ~optional_base() { destroy() ; }
>
>
> void assign ( optional_base const& rhs )
> {
> if (is_initialized())
> {
> if ( rhs.is_initialized() )
> assign_value(rhs.get_impl(), is_reference_predicate() );
> else destroy();
> }
> else
> {
> if ( rhs.is_initialized() )
> construct(rhs.get_impl());
> }
> }
>
>
> template<class U>
> void assign ( optional const& rhs )
> {
> if (is_initialized())
> {
> if ( rhs.is_initialized() )
> assign_value(static_cast<value_type>(rhs.get()), is_reference_predicate() );
> else destroy();
> }
> else
> {
> if ( rhs.is_initialized() )
> construct(static_cast<value_type>(rhs.get()));
> }
> }
>
>
> void assign ( argument_type val )
> {
> if (is_initialized())
> assign_value(val, is_reference_predicate() );
> else construct(val);
> }
>
>
>
> void assign ( none_t ) { destroy(); }
>
>
> template<class Expr>
> void assign_expr ( Expr const& expr, Expr const* tag )
> {
> if (is_initialized())
> assign_expr_to_initialized(expr,tag);
> else construct(expr,tag);
> }
>
>
> public :
>
>
>
> void reset() { destroy(); }
>
>
> void reset ( argument_type val ) { assign(val); }
>
>
>
>
> pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; }
> pointer_type get_ptr() { return m_initialized ? get_ptr_impl() : 0 ; }
>
> bool is_initialized() const { return m_initialized ; }
>
> protected :
>
> void construct ( argument_type val )
> {
> new (m_storage.address()) internal_type(val) ;
> m_initialized = true ;
> }
>
>
>
> template<class Expr>
> void construct ( Expr const& factory, in_place_factory_base const* )
> {
> static_assert(::boost::mpl::not_<is_reference_predicate>::value, "::boost::mpl::not_<is_reference_predicate>::value") ;
> boost_optional_detail::construct<value_type>(factory, m_storage.address());
> m_initialized = true ;
> }
>
>
> template<class Expr>
> void construct ( Expr const& factory, typed_in_place_factory_base const* )
> {
> static_assert(::boost::mpl::not_<is_reference_predicate>::value, "::boost::mpl::not_<is_reference_predicate>::value") ;
> factory.apply(m_storage.address()) ;
> m_initialized = true ;
> }
>
> template<class Expr>
> void assign_expr_to_initialized ( Expr const& factory, in_place_factory_base const* tag )
> {
> destroy();
> construct(factory,tag);
> }
>
>
> template<class Expr>
> void assign_expr_to_initialized ( Expr const& factory, typed_in_place_factory_base const* tag )
> {
> destroy();
> construct(factory,tag);
> }
>
>
>
>
>
>
> template<class Expr>
> void construct ( Expr const& expr, void const* )
> {
> new (m_storage.address()) internal_type(expr) ;
> m_initialized = true ;
> }
>
>
>
>
>
> template<class Expr>
> void assign_expr_to_initialized ( Expr const& expr, void const* )
> {
> assign_value(expr, is_reference_predicate());
> }
># 433 "/usr/include/boost/optional/optional.hpp" 3 4
> void assign_value ( argument_type val, is_not_reference_tag ) { get_impl() = val; }
> void assign_value ( argument_type val, is_reference_tag ) { construct(val); }
>
> void destroy()
> {
> if ( m_initialized )
> destroy_impl(is_reference_predicate()) ;
> }
>
> unspecified_bool_type safe_bool() const { return m_initialized ? &this_type::is_initialized : 0 ; }
>
> reference_const_type get_impl() const { return dereference(get_object(), is_reference_predicate() ) ; }
> reference_type get_impl() { return dereference(get_object(), is_reference_predicate() ) ; }
>
> pointer_const_type get_ptr_impl() const { return cast_ptr(get_object(), is_reference_predicate() ) ; }
> pointer_type get_ptr_impl() { return cast_ptr(get_object(), is_reference_predicate() ) ; }
>
> private :
>
>
>
>
> internal_type const* get_object() const
> {
> union { void const* ap_pvoid; internal_type const* as_ptype; } caster = { m_storage.address() };
> return caster.as_ptype;
> }
> internal_type * get_object()
> {
> union { void* ap_pvoid; internal_type* as_ptype; } caster = { m_storage.address() };
> return caster.as_ptype;
> }
>
>
>
>
>
>
> reference_const_type dereference( internal_type const* p, is_not_reference_tag ) const { return *p ; }
> reference_type dereference( internal_type* p, is_not_reference_tag ) { return *p ; }
> reference_const_type dereference( internal_type const* p, is_reference_tag ) const { return p->get() ; }
> reference_type dereference( internal_type* p, is_reference_tag ) { return p->get() ; }
>
>
>
>
> void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->T::~T() ; m_initialized = false ; }
>
>
> void destroy_impl ( is_reference_tag ) { m_initialized = false ; }
>
>
>
>
> pointer_const_type cast_ptr( internal_type const* p, is_not_reference_tag ) const { return p ; }
> pointer_type cast_ptr( internal_type * p, is_not_reference_tag ) { return p ; }
> pointer_const_type cast_ptr( internal_type const* p, is_reference_tag ) const { return &p->get() ; }
> pointer_type cast_ptr( internal_type * p, is_reference_tag ) { return &p->get() ; }
>
> bool m_initialized ;
> storage_type m_storage ;
>} ;
>
>}
>
>template<class T>
>class optional : public optional_detail::optional_base<T>
>{
> typedef optional_detail::optional_base<T> base ;
>
> typedef typename base::unspecified_bool_type unspecified_bool_type ;
>
> public :
>
> typedef optional<T> this_type ;
>
> typedef typename base::value_type value_type ;
> typedef typename base::reference_type reference_type ;
> typedef typename base::reference_const_type reference_const_type ;
> typedef typename base::pointer_type pointer_type ;
> typedef typename base::pointer_const_type pointer_const_type ;
> typedef typename base::argument_type argument_type ;
>
>
>
> optional() : base() {}
>
>
>
> optional( none_t none_ ) : base(none_) {}
>
>
>
> optional ( argument_type val ) : base(val) {}
>
>
>
> optional ( bool cond, argument_type val ) : base(cond,val) {}
>
>
>
>
>
>
>
> template<class U>
> explicit optional ( optional const& rhs )
> :
> base()
> {
> if ( rhs.is_initialized() )
> this->construct(rhs.get());
> }
># 558 "/usr/include/boost/optional/optional.hpp" 3 4
> template<class Expr>
> explicit optional ( Expr const& expr ) : base(expr,boost::addressof(expr)) {}
>
>
>
>
> optional ( optional const& rhs ) : base( static_cast<base const&>(rhs) ) {}
>
>
> ~optional() {}
>
>
>
>
> template<class Expr>
> optional& operator= ( Expr const& expr )
> {
> this->assign_expr(expr,boost::addressof(expr));
> return *this ;
> }
>
>
>
>
>
>
>
> template<class U>
> optional& operator= ( optional const& rhs )
> {
> this->assign(rhs);
> return *this ;
> }
>
>
>
>
>
> optional& operator= ( optional const& rhs )
> {
> this->assign( static_cast<base const&>(rhs) ) ;
> return *this ;
> }
>
>
>
> optional& operator= ( argument_type val )
> {
> this->assign( val ) ;
> return *this ;
> }
>
>
>
>
> optional& operator= ( none_t none_ )
> {
> this->assign( none_ ) ;
> return *this ;
> }
>
> void swap( optional & arg )
> {
>
> using boost::swap;
> swap(*this, arg);
> }
>
>
>
>
>
> reference_const_type get() const { ((void)0) ; return this->get_impl(); }
> reference_type get() { ((void)0) ; return this->get_impl(); }
>
>
> reference_const_type get_value_or ( reference_const_type v ) const { return this->is_initialized() ? get() : v ; }
> reference_type get_value_or ( reference_type v ) { return this->is_initialized() ? get() : v ; }
>
>
>
>
> pointer_const_type operator->() const { ((void)0) ; return this->get_ptr_impl() ; }
> pointer_type operator->() { ((void)0) ; return this->get_ptr_impl() ; }
>
>
>
>
> reference_const_type operator *() const { return this->get() ; }
> reference_type operator *() { return this->get() ; }
>
>
>
> operator unspecified_bool_type() const { return this->safe_bool() ; }
>
>
>
> bool operator!() const { return !this->is_initialized() ; }
>} ;
>
>
>template<class T>
>inline
>optional<T> make_optional ( T const& v )
>{
> return optional<T>(v);
>}
>
>
>template<class T>
>inline
>optional<T> make_optional ( bool cond, T const& v )
>{
> return optional<T>(cond,v);
>}
>
>
>
>template<class T>
>inline
>typename optional<T>::reference_const_type
>get ( optional<T> const& opt )
>{
> return opt.get() ;
>}
>
>template<class T>
>inline
>typename optional<T>::reference_type
>get ( optional<T>& opt )
>{
> return opt.get() ;
>}
>
>
>
>template<class T>
>inline
>typename optional<T>::pointer_const_type
>get ( optional<T> const* opt )
>{
> return opt->get_ptr() ;
>}
>
>template<class T>
>inline
>typename optional<T>::pointer_type
>get ( optional<T>* opt )
>{
> return opt->get_ptr() ;
>}
>
>
>
>template<class T>
>inline
>typename optional<T>::reference_const_type
>get_optional_value_or ( optional<T> const& opt, typename optional<T>::reference_const_type v )
>{
> return opt.get_value_or(v) ;
>}
>
>template<class T>
>inline
>typename optional<T>::reference_type
>get_optional_value_or ( optional<T>& opt, typename optional<T>::reference_type v )
>{
> return opt.get_value_or(v) ;
>}
>
>
>
>template<class T>
>inline
>typename optional<T>::pointer_const_type
>get_pointer ( optional<T> const& opt )
>{
> return opt.get_ptr() ;
>}
>
>template<class T>
>inline
>typename optional<T>::pointer_type
>get_pointer ( optional<T>& opt )
>{
> return opt.get_ptr() ;
>}
># 754 "/usr/include/boost/optional/optional.hpp" 3 4
>template<class T>
>inline
>bool operator == ( optional<T> const& x, optional<T> const& y )
>{ return equal_pointees(x,y); }
>
>template<class T>
>inline
>bool operator < ( optional<T> const& x, optional<T> const& y )
>{ return less_pointees(x,y); }
>
>template<class T>
>inline
>bool operator != ( optional<T> const& x, optional<T> const& y )
>{ return !( x == y ) ; }
>
>template<class T>
>inline
>bool operator > ( optional<T> const& x, optional<T> const& y )
>{ return y < x ; }
>
>template<class T>
>inline
>bool operator <= ( optional<T> const& x, optional<T> const& y )
>{ return !( y < x ) ; }
>
>template<class T>
>inline
>bool operator >= ( optional<T> const& x, optional<T> const& y )
>{ return !( x < y ) ; }
>
>
>
>
>
>template<class T>
>inline
>bool operator == ( optional<T> const& x, T const& y )
>{ return equal_pointees(x, optional<T>(y)); }
>
>template<class T>
>inline
>bool operator < ( optional<T> const& x, T const& y )
>{ return less_pointees(x, optional<T>(y)); }
>
>template<class T>
>inline
>bool operator != ( optional<T> const& x, T const& y )
>{ return !( x == y ) ; }
>
>template<class T>
>inline
>bool operator > ( optional<T> const& x, T const& y )
>{ return y < x ; }
>
>template<class T>
>inline
>bool operator <= ( optional<T> const& x, T const& y )
>{ return !( y < x ) ; }
>
>template<class T>
>inline
>bool operator >= ( optional<T> const& x, T const& y )
>{ return !( x < y ) ; }
>
>
>
>
>
>template<class T>
>inline
>bool operator == ( T const& x, optional<T> const& y )
>{ return equal_pointees( optional<T>(x), y ); }
>
>template<class T>
>inline
>bool operator < ( T const& x, optional<T> const& y )
>{ return less_pointees( optional<T>(x), y ); }
>
>template<class T>
>inline
>bool operator != ( T const& x, optional<T> const& y )
>{ return !( x == y ) ; }
>
>template<class T>
>inline
>bool operator > ( T const& x, optional<T> const& y )
>{ return y < x ; }
>
>template<class T>
>inline
>bool operator <= ( T const& x, optional<T> const& y )
>{ return !( y < x ) ; }
>
>template<class T>
>inline
>bool operator >= ( T const& x, optional<T> const& y )
>{ return !( x < y ) ; }
>
>
>
>
>
>
>template<class T>
>inline
>bool operator == ( optional<T> const& x, none_t )
>{ return equal_pointees(x, optional<T>() ); }
>
>template<class T>
>inline
>bool operator < ( optional<T> const& x, none_t )
>{ return less_pointees(x,optional<T>() ); }
>
>template<class T>
>inline
>bool operator != ( optional<T> const& x, none_t y )
>{ return !( x == y ) ; }
>
>template<class T>
>inline
>bool operator > ( optional<T> const& x, none_t y )
>{ return y < x ; }
>
>template<class T>
>inline
>bool operator <= ( optional<T> const& x, none_t y )
>{ return !( y < x ) ; }
>
>template<class T>
>inline
>bool operator >= ( optional<T> const& x, none_t y )
>{ return !( x < y ) ; }
>
>
>
>
>
>template<class T>
>inline
>bool operator == ( none_t , optional<T> const& y )
>{ return equal_pointees(optional<T>() ,y); }
>
>template<class T>
>inline
>bool operator < ( none_t , optional<T> const& y )
>{ return less_pointees(optional<T>() ,y); }
>
>template<class T>
>inline
>bool operator != ( none_t x, optional<T> const& y )
>{ return !( x == y ) ; }
>
>template<class T>
>inline
>bool operator > ( none_t x, optional<T> const& y )
>{ return y < x ; }
>
>template<class T>
>inline
>bool operator <= ( none_t x, optional<T> const& y )
>{ return !( y < x ) ; }
>
>template<class T>
>inline
>bool operator >= ( none_t x, optional<T> const& y )
>{ return !( x < y ) ; }
>
>namespace optional_detail {
>
>template<bool use_default_constructor> struct swap_selector;
>
>template<>
>struct swap_selector<true>
>{
> template<class T>
> static void optional_swap ( optional<T>& x, optional<T>& y )
> {
> const bool hasX = !!x;
> const bool hasY = !!y;
>
> if ( !hasX && !hasY )
> return;
>
> if( !hasX )
> x = boost::in_place();
> else if ( !hasY )
> y = boost::in_place();
>
>
> boost::swap(x.get(),y.get());
>
> if( !hasX )
> y = boost::none ;
> else if( !hasY )
> x = boost::none ;
> }
>};
>
>template<>
>struct swap_selector<false>
>{
> template<class T>
> static void optional_swap ( optional<T>& x, optional<T>& y )
> {
> const bool hasX = !!x;
> const bool hasY = !!y;
>
> if ( !hasX && hasY )
> {
> x = y.get();
> y = boost::none ;
> }
> else if ( hasX && !hasY )
> {
> y = x.get();
> x = boost::none ;
> }
> else if ( hasX && hasY )
> {
>
> boost::swap(x.get(),y.get());
> }
> }
>};
>
>}
>
>template<class T>
>struct optional_swap_should_use_default_constructor : has_nothrow_default_constructor<T> {} ;
>
>template<class T> inline void swap ( optional<T>& x, optional<T>& y )
>{
> optional_detail::swap_selector<optional_swap_should_use_default_constructor<T>::value>::optional_swap(x, y);
>}
>
>}
># 16 "/usr/include/boost/optional.hpp" 2 3 4
># 17 "/usr/include/boost/property_tree/id_translator.hpp" 2 3 4
>
>
>namespace boost { namespace property_tree
>{
>
>
> template <typename T>
> struct id_translator
> {
> typedef T internal_type;
> typedef T external_type;
>
> boost::optional<T> get_value(const T &v) { return v; }
> boost::optional<T> put_value(const T &v) { return v; }
> };
>
>
> template <typename T>
> struct translator_between<T, T>
> {
> typedef id_translator<T> type;
> };
>
>
>
> template <typename Ch, typename Traits, typename Alloc>
> struct translator_between< std::basic_string<Ch, Traits, Alloc>,
> std::basic_string<Ch, Traits, Alloc> >
> {
> typedef id_translator< std::basic_string<Ch, Traits, Alloc> > type;
> };
>
>}}
># 16 "/usr/include/boost/property_tree/string_path.hpp" 2 3 4
># 1 "/usr/include/boost/property_tree/exceptions.hpp" 1 3 4
># 17 "/usr/include/boost/property_tree/exceptions.hpp" 3 4
># 1 "/usr/include/boost/any.hpp" 1 3 4
># 36 "/usr/include/boost/any.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 37 "/usr/include/boost/any.hpp" 2 3 4
>
>
>namespace boost
>{
> class any
> {
> public:
>
> any() noexcept
> : content(0)
> {
> }
>
> template<typename ValueType>
> any(const ValueType & value)
> : content(new holder<ValueType>(value))
> {
> }
>
> any(const any & other)
> : content(other.content ? other.content->clone() : 0)
> {
> }
>
>
>
> any(any&& other) noexcept
> : content(other.content)
> {
> other.content = 0;
> }
>
>
> template<typename ValueType>
> any(ValueType&& value, typename boost::disable_if<boost::is_same<any&, ValueType> >::type* = 0)
> : content(new holder< typename remove_reference<ValueType>::type >(static_cast<ValueType&&>(value)))
> {
> }
>
>
> ~any() noexcept
> {
> delete content;
> }
>
> public:
>
> any & swap(any & rhs) noexcept
> {
> std::swap(content, rhs.content);
> return *this;
> }
># 106 "/usr/include/boost/any.hpp" 3 4
> any & operator=(const any& rhs)
> {
> any(rhs).swap(*this);
> return *this;
> }
>
>
> any & operator=(any&& rhs) noexcept
> {
> rhs.swap(*this);
> any().swap(rhs);
> return *this;
> }
>
>
> template <class ValueType>
> any & operator=(ValueType&& rhs)
> {
> any(static_cast<ValueType&&>(rhs)).swap(*this);
> return *this;
> }
>
>
> public:
>
> bool empty() const noexcept
> {
> return !content;
> }
>
> const std::type_info & type() const
> {
> return content ? content->type() : typeid(void);
> }
>
>
> private:
>
>
>
>
> class placeholder
> {
> public:
>
> virtual ~placeholder()
> {
> }
>
> public:
>
> virtual const std::type_info & type() const = 0;
>
> virtual placeholder * clone() const = 0;
>
> };
>
> template<typename ValueType>
> class holder : public placeholder
> {
> public:
>
> holder(const ValueType & value)
> : held(value)
> {
> }
>
>
> holder(ValueType&& value)
> : held(static_cast< ValueType&& >(value))
> {
> }
>
> public:
>
> virtual const std::type_info & type() const
> {
> return typeid(ValueType);
> }
>
> virtual placeholder * clone() const
> {
> return new holder(held);
> }
>
> public:
>
> ValueType held;
>
> private:
> holder & operator=(const holder &);
> };
>
>
>
> private:
>
> template<typename ValueType>
> friend ValueType * any_cast(any *) noexcept;
>
> template<typename ValueType>
> friend ValueType * unsafe_any_cast(any *) noexcept;
>
>
>
>
>
>
>
> placeholder * content;
>
> };
>
> inline void swap(any & lhs, any & rhs) noexcept
> {
> lhs.swap(rhs);
> }
>
> class bad_any_cast : public std::bad_cast
> {
> public:
> virtual const char * what() const throw()
> {
> return "boost::bad_any_cast: "
> "failed conversion using boost::any_cast";
> }
> };
>
> template<typename ValueType>
> ValueType * any_cast(any * operand) noexcept
> {
> return operand &&
>
> std::strcmp(operand->type().name(), typeid(ValueType).name()) == 0
>
>
>
> ? &static_cast<any::holder<ValueType> *>(operand->content)->held
> : 0;
> }
>
> template<typename ValueType>
> inline const ValueType * any_cast(const any * operand) noexcept
> {
> return any_cast<ValueType>(const_cast<any *>(operand));
> }
>
> template<typename ValueType>
> ValueType any_cast(any & operand)
> {
> typedef typename remove_reference<ValueType>::type nonref;
># 268 "/usr/include/boost/any.hpp" 3 4
> nonref * result = any_cast<nonref>(&operand);
> if(!result)
> boost::throw_exception(bad_any_cast());
> return *result;
> }
>
> template<typename ValueType>
> inline ValueType any_cast(const any & operand)
> {
> typedef typename remove_reference<ValueType>::type nonref;
>
>
>
>
>
>
>
> return any_cast<const nonref &>(const_cast<any &>(operand));
> }
>
>
>
>
>
>
> template<typename ValueType>
> inline ValueType * unsafe_any_cast(any * operand) noexcept
> {
> return &static_cast<any::holder<ValueType> *>(operand->content)->held;
> }
>
> template<typename ValueType>
> inline const ValueType * unsafe_any_cast(const any * operand) noexcept
> {
> return unsafe_any_cast<ValueType>(const_cast<any *>(operand));
> }
>}
># 18 "/usr/include/boost/property_tree/exceptions.hpp" 2 3 4
>
>
>
>namespace boost { namespace property_tree
>{
>
>
>
>
> class ptree_error : public std::runtime_error
> {
> public:
>
>
> ptree_error(const std::string &what);
>
> ~ptree_error() throw();
> };
>
>
>
>
> class ptree_bad_data : public ptree_error
> {
> public:
>
>
>
>
>
> template<class T> ptree_bad_data(const std::string &what,
> const T &data);
>
> ~ptree_bad_data() throw();
>
>
>
>
> template<class T> T data() const;
> private:
> boost::any m_data;
> };
>
>
>
>
> class ptree_bad_path : public ptree_error
> {
> public:
>
>
>
> template<class T> ptree_bad_path(const std::string &what,
> const T &path);
>
> ~ptree_bad_path() throw();
>
>
>
> template<class T> T path() const;
> private:
> boost::any m_path;
> };
>
>}}
>
># 1 "/usr/include/boost/property_tree/detail/exception_implementation.hpp" 1 3 4
># 14 "/usr/include/boost/property_tree/detail/exception_implementation.hpp" 3 4
>namespace boost { namespace property_tree
>{
>
> namespace detail
> {
>
>
> template<class P> inline
> std::string prepare_bad_path_what(const std::string &what,
> const P &path)
> {
> return what + " (" + path.dump() + ")";
> }
>
> }
>
>
>
>
> inline ptree_error::ptree_error(const std::string &w):
> std::runtime_error(w)
> {
> }
>
> inline ptree_error::~ptree_error() throw()
> {
> }
>
>
>
>
> template<class D> inline
> ptree_bad_data::ptree_bad_data(const std::string &w, const D &d):
> ptree_error(w), m_data(d)
> {
> }
>
> inline ptree_bad_data::~ptree_bad_data() throw()
> {
> }
>
> template<class D> inline
> D ptree_bad_data::data() const
> {
> return boost::any_cast<D>(m_data);
> }
>
>
>
>
> template<class P> inline
> ptree_bad_path::ptree_bad_path(const std::string &w, const P &p):
> ptree_error(detail::prepare_bad_path_what(w, p)), m_path(p)
> {
>
> }
>
> inline ptree_bad_path::~ptree_bad_path() throw()
> {
> }
>
> template<class P> inline
> P ptree_bad_path::path() const
> {
> return boost::any_cast(m_path);
> }
>
>}}
># 85 "/usr/include/boost/property_tree/exceptions.hpp" 2 3 4
># 17 "/usr/include/boost/property_tree/string_path.hpp" 2 3 4
># 1 "/usr/include/boost/property_tree/detail/ptree_utils.hpp" 1 3 4
># 21 "/usr/include/boost/property_tree/detail/ptree_utils.hpp" 3 4
>namespace boost { namespace property_tree { namespace detail
>{
>
> template<class T>
> struct less_nocase
> {
> typedef typename T::value_type Ch;
> std::locale m_locale;
> inline bool operator()(Ch c1, Ch c2) const
> {
> return std::toupper(c1, m_locale) < std::toupper(c2, m_locale);
> }
> inline bool operator()(const T &t1, const T &t2) const
> {
> return std::lexicographical_compare(t1.begin(), t1.end(),
> t2.begin(), t2.end(), *this);
> }
> };
>
> template <typename Ch>
> struct is_character : public boost::false_type {};
> template <>
> struct is_character<char> : public boost::true_type {};
> template <>
> struct is_character<wchar_t> : public boost::true_type {};
>
>
> template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_internal_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper const volatile* , boost::mpl::aux::type_wrapper<typename U::internal_type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
> template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_external_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper const volatile* , boost::mpl::aux::type_wrapper<typename U::external_type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
> template <typename T>
> struct is_translator : public boost::mpl::and_<
> has_internal_type<T>, has_external_type<T> > {};
>
>
>
>
> template<class Ch>
> std::basic_string<Ch> widen(const char *text)
> {
> std::basic_string<Ch> result;
> while (*text)
> {
> result += Ch(*text);
> ++text;
> }
> return result;
> }
>
>
> template<class Ch>
> std::string narrow(const Ch *text)
> {
> std::string result;
> while (*text)
> {
> if (*text < 0 || *text > (std::numeric_limits<char>::max)())
> result += '*';
> else
> result += char(*text);
> ++text;
> }
> return result;
> }
>
>
> template<class Ch>
> std::basic_string<Ch> trim(const std::basic_string<Ch> &s,
> const std::locale &loc = std::locale())
> {
> typename std::basic_string<Ch>::const_iterator first = s.begin();
> typename std::basic_string<Ch>::const_iterator end = s.end();
> while (first != end && std::isspace(*first, loc))
> ++first;
> if (first == end)
> return std::basic_string<Ch>();
> typename std::basic_string<Ch>::const_iterator last = end;
> do --last; while (std::isspace(*last, loc));
> if (first != s.begin() || last + 1 != end)
> return std::basic_string<Ch>(first, last + 1);
> else
> return s;
> }
>
>} } }
># 18 "/usr/include/boost/property_tree/string_path.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 21 "/usr/include/boost/property_tree/string_path.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost { namespace property_tree
>{
> namespace detail
> {
> template <typename Sequence, typename Iterator>
> void append_and_preserve_iter(Sequence &s, const Sequence &r,
> Iterator &, std::forward_iterator_tag)
> {
>
>
> s.insert(s.end(), r.begin(), r.end());
> }
> template <typename Sequence, typename Iterator>
> void append_and_preserve_iter(Sequence &s, const Sequence &r,
> Iterator &it,
> std::random_access_iterator_tag)
> {
>
> typename std::iterator_traits<Iterator>::difference_type idx =
> it - s.begin();
> s.insert(s.end(), r.begin(), r.end());
> it = s.begin() + idx;
> }
>
> template <typename Sequence>
> inline std::string dump_sequence(const Sequence &)
> {
> return "<undumpable sequence>";
> }
> inline std::string dump_sequence(const std::string &s)
> {
> return s;
> }
>
> inline std::string dump_sequence(const std::wstring &s)
> {
> return narrow(s.c_str());
> }
>
> }
># 81 "/usr/include/boost/property_tree/string_path.hpp" 3 4
> template <typename String, typename Translator>
> class string_path
> {
> static_assert((is_same<String, typename Translator::internal_type>::value), "(is_same<String, typename Translator::internal_type>::value)")
> ;
> public:
> typedef typename Translator::external_type key_type;
> typedef typename String::value_type char_type;
>
>
> explicit string_path(char_type separator = char_type('.'));
>
>
>
>
>
>
> string_path(const String &value, char_type separator = char_type('.'),
> Translator tr = Translator());
># 108 "/usr/include/boost/property_tree/string_path.hpp" 3 4
> string_path(const char_type *value,
> char_type separator = char_type('.'),
> Translator tr = Translator());
>
>
> string_path(const string_path &o);
> string_path& operator =(const string_path &o);
>
>
> key_type reduce();
>
>
> bool empty() const;
>
>
> bool single() const;
>
>
> char_type separator() const { return m_separator; }
>
> std::string dump() const {
> return detail::dump_sequence(m_value);
> }
>
>
>
> string_path& operator /=(const string_path &o) {
>
>
>
> ((void)0)
>
>
> ;
> if(!o.empty()) {
> String sub;
> if(!this->empty()) {
> sub.push_back(m_separator);
> }
> sub.insert(sub.end(), o.cstart(), o.m_value.end());
> detail::append_and_preserve_iter(m_value, sub, m_start,
> typename std::iterator_traits<s_iter>::iterator_category());
> }
> return *this;
> }
>
> private:
> typedef typename String::iterator s_iter;
> typedef typename String::const_iterator s_c_iter;
> String m_value;
> char_type m_separator;
> Translator m_tr;
> s_iter m_start;
> s_c_iter cstart() const { return m_start; }
> };
>
> template <typename String, typename Translator> inline
> string_path<String, Translator>::string_path(char_type separator)
> : m_separator(separator), m_start(m_value.begin())
> {}
>
> template <typename String, typename Translator> inline
> string_path<String, Translator>::string_path(const String &value,
> char_type separator,
> Translator tr)
> : m_value(value), m_separator(separator),
> m_tr(tr), m_start(m_value.begin())
> {}
>
> template <typename String, typename Translator> inline
> string_path<String, Translator>::string_path(const char_type *value,
> char_type separator,
> Translator tr)
> : m_value(value), m_separator(separator),
> m_tr(tr), m_start(m_value.begin())
> {}
>
> template <typename String, typename Translator> inline
> string_path<String, Translator>::string_path(const string_path &o)
> : m_value(o.m_value), m_separator(o.m_separator),
> m_tr(o.m_tr), m_start(m_value.begin())
> {
> std::advance(m_start, std::distance(o.m_value.begin(), o.cstart()));
> }
>
> template <typename String, typename Translator> inline
> string_path<String, Translator>&
> string_path<String, Translator>::operator =(const string_path &o)
> {
> m_value = o.m_value;
> m_separator = o.m_separator;
> m_tr = o.m_tr;
> m_start = m_value.begin();
> std::advance(m_start, std::distance(o.m_value.begin(), o.cstart()));
> return *this;
> }
>
> template <typename String, typename Translator>
> typename Translator::external_type string_path<String, Translator>::reduce()
> {
> ((void)0);
>
> s_iter next_sep = std::find(m_start, m_value.end(), m_separator);
> String part(m_start, next_sep);
> m_start = next_sep;
> if(!empty()) {
>
> ++m_start;
> }
>
> if(optional<key_type> key = m_tr.get_value(part)) {
> return *key;
> }
> ::boost::exception_detail::throw_exception_(ptree_bad_path("Path syntax error", *this),__PRETTY_FUNCTION__,"/usr/include/boost/property_tree/string_path.hpp",221);
> }
>
> template <typename String, typename Translator> inline
> bool string_path<String, Translator>::empty() const
> {
> return m_start == m_value.end();
> }
>
> template <typename String, typename Translator> inline
> bool string_path<String, Translator>::single() const
> {
> return std::find(static_cast<s_c_iter>(m_start),
> m_value.end(), m_separator)
> == m_value.end();
> }
>
>
>
> template <typename Ch, typename Traits, typename Alloc>
> struct path_of< std::basic_string<Ch, Traits, Alloc> >
> {
> typedef std::basic_string<Ch, Traits, Alloc> _string;
> typedef string_path< _string, id_translator<_string> > type;
> };
>
> template <typename String, typename Translator> inline
> string_path<String, Translator> operator /(
> string_path<String, Translator> p1,
> const string_path<String, Translator> &p2)
> {
> p1 /= p2;
> return p1;
> }
>
>
> template <typename String, typename Translator> inline
> string_path<String, Translator> operator /(
> string_path<String, Translator> p1,
> const typename String::value_type *p2)
> {
> p1 /= p2;
> return p1;
> }
>
> template <typename String, typename Translator> inline
> string_path<String, Translator> operator /(
> const typename String::value_type *p1,
> const string_path<String, Translator> &p2)
> {
> string_path<String, Translator> t(p1);
> t /= p2;
> return t;
> }
>
>}}
># 17 "/usr/include/boost/property_tree/ptree.hpp" 2 3 4
># 1 "/usr/include/boost/property_tree/stream_translator.hpp" 1 3 4
># 17 "/usr/include/boost/property_tree/stream_translator.hpp" 3 4
># 1 "/usr/include/boost/optional/optional_io.hpp" 1 3 4
># 29 "/usr/include/boost/optional/optional_io.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 30 "/usr/include/boost/optional/optional_io.hpp" 2 3 4
>
># 1 "/usr/include/boost/utility/value_init.hpp" 1 3 4
># 28 "/usr/include/boost/utility/value_init.hpp" 3 4
># 1 "/usr/include/boost/type_traits/cv_traits.hpp" 1 3 4
># 29 "/usr/include/boost/utility/value_init.hpp" 2 3 4
>
>
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 32 "/usr/include/boost/utility/value_init.hpp" 2 3 4
># 63 "/usr/include/boost/utility/value_init.hpp" 3 4
>namespace boost {
>
>template<class T>
>class initialized
>{
> private :
> struct wrapper
> {
>
> typename
>
> remove_const<T>::type data;
>
> wrapper()
> :
> data()
> {
> }
>
> wrapper(T const & arg)
> :
> data(arg)
> {
> }
> };
>
> mutable
>
> typename
>
> aligned_storage<sizeof(wrapper), alignment_of<wrapper>::value>::type x;
>
> wrapper * wrapper_address() const
> {
> return static_cast<wrapper *>( static_cast<void*>(&x));
> }
>
> public :
>
> initialized()
> {
>
>
>
> new (wrapper_address()) wrapper();
> }
>
> initialized(initialized const & arg)
> {
> new (wrapper_address()) wrapper( static_cast<wrapper const &>(*(arg.wrapper_address())));
> }
>
> explicit initialized(T const & arg)
> {
> new (wrapper_address()) wrapper(arg);
> }
>
> initialized & operator=(initialized const & arg)
> {
>
> static_assert(! is_const<T>::value, "! is_const<T>::value");
> *wrapper_address() = static_cast<wrapper const &>(*(arg.wrapper_address()));
> return *this;
> }
>
> ~initialized()
> {
> wrapper_address()->wrapper::~wrapper();
> }
>
> T const & data() const
> {
> return wrapper_address()->data;
> }
>
> T& data()
> {
> return wrapper_address()->data;
> }
>
> void swap(initialized & arg)
> {
> ::boost::swap( this->data(), arg.data() );
> }
>
> operator T const &() const
> {
> return wrapper_address()->data;
> }
>
> operator T&()
> {
> return wrapper_address()->data;
> }
>
>} ;
>
>template<class T>
>T const& get ( initialized<T> const& x )
>{
> return x.data() ;
>}
>
>template<class T>
>T& get ( initialized<T>& x )
>{
> return x.data() ;
>}
>
>template<class T>
>void swap ( initialized<T> & lhs, initialized<T> & rhs )
>{
> lhs.swap(rhs) ;
>}
>
>template<class T>
>class value_initialized
>{
> private :
>
>
> initialized<T> m_data;
>
> public :
>
> value_initialized()
> :
> m_data()
> { }
>
> T const & data() const
> {
> return m_data.data();
> }
>
> T& data()
> {
> return m_data.data();
> }
>
> void swap(value_initialized & arg)
> {
> m_data.swap(arg.m_data);
> }
>
> operator T const &() const
> {
> return m_data;
> }
>
> operator T&()
> {
> return m_data;
> }
>} ;
>
>
>template<class T>
>T const& get ( value_initialized<T> const& x )
>{
> return x.data() ;
>}
>
>template<class T>
>T& get ( value_initialized<T>& x )
>{
> return x.data() ;
>}
>
>template<class T>
>void swap ( value_initialized<T> & lhs, value_initialized<T> & rhs )
>{
> lhs.swap(rhs) ;
>}
>
>
>class initialized_value_t
>{
> public :
>
> template <class T> operator T() const
> {
> return initialized<T>().data();
> }
>};
>
>initialized_value_t const initialized_value = {} ;
>
>
>}
># 32 "/usr/include/boost/optional/optional_io.hpp" 2 3 4
>
>namespace boost
>{
>
>
>
>
>
>template<class CharType, class CharTrait, class T>
>inline
>std::basic_ostream<CharType, CharTrait>&
>operator<<(std::basic_ostream<CharType, CharTrait>& out, optional<T> const& v)
>
>{
> if ( out.good() )
> {
> if ( !v )
> out << "--" ;
> else out << ' ' << *v ;
> }
>
> return out;
>}
>
>
>
>
>
>template<class CharType, class CharTrait, class T>
>inline
>std::basic_istream<CharType, CharTrait>&
>operator>>(std::basic_istream<CharType, CharTrait>& in, optional<T>& v)
>
>{
> if (in.good())
> {
> int d = in.get();
> if (d == ' ')
> {
> T x;
> in >> x;
> v = x;
> }
> else
> {
> if (d == '-')
> {
> d = in.get();
>
> if (d == '-')
> {
> v = none;
> return in;
> }
> }
>
> in.setstate( std::ios::failbit );
> }
> }
>
> return in;
>}
>
>}
># 18 "/usr/include/boost/property_tree/stream_translator.hpp" 2 3 4
># 26 "/usr/include/boost/property_tree/stream_translator.hpp" 3 4
>namespace boost { namespace property_tree
>{
>
> template <typename Ch, typename Traits, typename E, typename Enabler = void>
> struct customize_stream
> {
> static void insert(std::basic_ostream<Ch, Traits>& s, const E& e) {
> s << e;
> }
> static void extract(std::basic_istream<Ch, Traits>& s, E& e) {
> s >> e;
> if(!s.eof()) {
> s >> std::ws;
> }
> }
> };
>
>
> template <typename Ch, typename Traits>
> struct customize_stream<Ch, Traits, Ch, void>
> {
> static void insert(std::basic_ostream<Ch, Traits>& s, Ch e) {
> s << e;
> }
> static void extract(std::basic_istream<Ch, Traits>& s, Ch& e) {
> s.unsetf(std::ios_base::skipws);
> s >> e;
> }
> };
>
>
>
> namespace detail
> {
> template <bool is_specialized>
> struct is_inexact_impl
> {
> template <typename T>
> struct test
> {
> typedef boost::false_type type;
> };
> };
> template <>
> struct is_inexact_impl<true>
> {
> template <typename T>
> struct test
> {
> typedef boost::integral_constant<bool,
> !std::numeric_limits<T>::is_exact> type;
> };
> };
>
> template <typename F>
> struct is_inexact
> {
> typedef typename boost::decay<F>::type decayed;
> typedef typename is_inexact_impl<
> std::numeric_limits<decayed>::is_specialized
> >::template test<decayed>::type type;
> static const bool value = type::value;
> };
> }
>
> template <typename Ch, typename Traits, typename F>
> struct customize_stream<Ch, Traits, F,
> typename boost::enable_if< detail::is_inexact<F> >::type
> >
> {
> static void insert(std::basic_ostream<Ch, Traits>& s, const F& e) {
> s.precision(std::numeric_limits<F>::digits10 + 1);
> s << e;
> }
> static void extract(std::basic_istream<Ch, Traits>& s, F& e) {
> s >> e;
> if(!s.eof()) {
> s >> std::ws;
> }
> }
> };
>
> template <typename Ch, typename Traits>
> struct customize_stream<Ch, Traits, bool, void>
> {
> static void insert(std::basic_ostream<Ch, Traits>& s, bool e) {
> s.setf(std::ios_base::boolalpha);
> s << e;
> }
> static void extract(std::basic_istream<Ch, Traits>& s, bool& e) {
> s >> e;
> if(s.fail()) {
>
> s.clear();
> s.setf(std::ios_base::boolalpha);
> s >> e;
> }
> if(!s.eof()) {
> s >> std::ws;
> }
> }
> };
>
> template <typename Ch, typename Traits>
> struct customize_stream<Ch, Traits, signed char, void>
> {
> static void insert(std::basic_ostream<Ch, Traits>& s, signed char e) {
> s << (int)e;
> }
> static void extract(std::basic_istream<Ch, Traits>& s, signed char& e) {
> int i;
> s >> i;
>
> if(i > (std::numeric_limits<signed char>::max)() ||
> i < (std::numeric_limits<signed char>::min)())
> {
> s.clear();
> return;
> }
> e = (signed char)i;
> if(!s.eof()) {
> s >> std::ws;
> }
> }
> };
>
> template <typename Ch, typename Traits>
> struct customize_stream<Ch, Traits, unsigned char, void>
> {
> static void insert(std::basic_ostream<Ch, Traits>& s, unsigned char e) {
> s << (unsigned)e;
> }
> static void extract(std::basic_istream<Ch,Traits>& s, unsigned char& e){
> unsigned i;
> s >> i;
>
> if(i > (std::numeric_limits<unsigned char>::max)()) {
> s.clear();
> return;
> }
> e = (unsigned char)i;
> if(!s.eof()) {
> s >> std::ws;
> }
> }
> };
>
>
> template <typename Ch, typename Traits, typename Alloc, typename E>
> class stream_translator
> {
> typedef customize_stream<Ch, Traits, E> customized;
> public:
> typedef std::basic_string<Ch, Traits, Alloc> internal_type;
> typedef E external_type;
>
> explicit stream_translator(std::locale loc = std::locale())
> : m_loc(loc)
> {}
>
> boost::optional<E> get_value(const internal_type &v) {
> std::basic_istringstream<Ch, Traits, Alloc> iss(v);
> iss.imbue(m_loc);
> E e;
> customized::extract(iss, e);
> if(iss.fail() || iss.bad() || iss.get() != Traits::eof()) {
> return boost::optional<E>();
> }
> return e;
> }
> boost::optional<internal_type> put_value(const E &v) {
> std::basic_ostringstream<Ch, Traits, Alloc> oss;
> oss.imbue(m_loc);
> customized::insert(oss, v);
> if(oss) {
> return oss.str();
> }
> return boost::optional<internal_type>();
> }
>
> private:
> std::locale m_loc;
> };
>
>
>
>
> template <typename Ch, typename Traits, typename Alloc, typename E>
> struct translator_between<std::basic_string<Ch, Traits, Alloc>, E>
> {
> typedef stream_translator<Ch, Traits, Alloc, E> type;
> };
>
>}}
># 18 "/usr/include/boost/property_tree/ptree.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/multi_index_container.hpp" 1 3 4
># 20 "/usr/include/boost/multi_index_container.hpp" 3 4
># 1 "/usr/include/boost/detail/allocator_utilities.hpp" 1 3 4
># 17 "/usr/include/boost/detail/allocator_utilities.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 18 "/usr/include/boost/detail/allocator_utilities.hpp" 2 3 4
>
>
>
>namespace boost{
>
>namespace detail{
>
>
>
>
>
>
>namespace allocator{
>
>
>
>
>
>
>template<typename Type>
>class partial_std_allocator_wrapper:public std::allocator<Type>
>{
>public:
>
>
>
>
>
> typedef Type value_type;
>
> partial_std_allocator_wrapper(){};
>
> template<typename Other>
> partial_std_allocator_wrapper(const partial_std_allocator_wrapper<Other>&){}
>
> partial_std_allocator_wrapper(const std::allocator<Type>& x):
> std::allocator<Type>(x)
> {
> };
># 70 "/usr/include/boost/detail/allocator_utilities.hpp" 3 4
>};
># 101 "/usr/include/boost/detail/allocator_utilities.hpp" 3 4
>template<typename Allocator>
>struct is_partial_std_allocator
>{
> static const bool value=false;
>};
>
>
>
>
>
>template<typename Allocator,typename Type>
>struct partial_std_allocator_rebind_to
>{
> typedef partial_std_allocator_wrapper<Type> type;
>};
># 142 "/usr/include/boost/detail/allocator_utilities.hpp" 3 4
>template<typename Allocator>
>struct rebinder
>{
> template<typename Type>
> struct result
> {
> typedef typename Allocator::template
> rebind<Type>::other other;
> };
>};
>
>
>template<typename Allocator,typename Type>
>struct compliant_allocator_rebind_to
>{
> typedef typename rebinder<Allocator>::
> template result<Type>::other type;
>};
>
>
>
>template<typename Allocator,typename Type>
>struct rebind_to:
> mpl::eval_if_c<
> is_partial_std_allocator<Allocator>::value,
> partial_std_allocator_rebind_to<Allocator,Type>,
> compliant_allocator_rebind_to<Allocator,Type>
> >
>{
>};
>
>
>
>template<typename Type>
>void construct(void* p,const Type& t)
>{
> new (p) Type(t);
>}
># 190 "/usr/include/boost/detail/allocator_utilities.hpp" 3 4
>template<typename Type>
>void destroy(const Type* p)
>{
>
>
>
>
> p->~Type();
>
>
>}
>
>
>
>
>
>}
>
>}
>
>}
># 21 "/usr/include/boost/multi_index_container.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/at.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/at.hpp" 3 4
># 1 "/usr/include/boost/mpl/at_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/at_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct at_impl;
>template< typename Sequence, typename N > struct at;
>
>}}
># 18 "/usr/include/boost/mpl/at.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/at_impl.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/at_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/begin_end.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/begin_end.hpp" 3 4
># 1 "/usr/include/boost/mpl/begin_end_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/begin_end_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct begin_impl;
>template< typename Tag > struct end_impl;
>
>template< typename Sequence > struct begin;
>template< typename Sequence > struct end;
>
>}}
># 18 "/usr/include/boost/mpl/begin_end.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/sequence_tag_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/sequence_tag_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>struct nested_begin_end_tag;
>struct non_sequence_tag;
>
>template< typename Sequence > struct sequence_tag;
>
>}}
># 19 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/aux_/has_begin.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/has_begin.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_begin { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper const volatile* , boost::mpl::aux::type_wrapper<typename U::begin>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
>}}}
># 22 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/aux_/traits_lambda_spec.hpp" 1 3 4
># 24 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 2 3 4
>
>
>namespace boost { namespace mpl {
>
>
>namespace aux {
>
>template< typename Sequence >
>struct begin_type
>{
> typedef typename Sequence::begin type;
>};
>template< typename Sequence >
>struct end_type
>{
> typedef typename Sequence::end type;
>};
>
>}
>
>
>
>
>
>template< typename Tag >
>struct begin_impl
>{
> template< typename Sequence > struct apply
> {
> typedef typename eval_if<aux::has_begin<Sequence, true_>,
> aux::begin_type<Sequence>, void_>::type type;
> };
>};
>
>template< typename Tag >
>struct end_impl
>{
> template< typename Sequence > struct apply
> {
> typedef typename eval_if<aux::has_begin<Sequence, true_>,
> aux::end_type<Sequence>, void_>::type type;
> };
>};
># 82 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 3 4
>template<> struct begin_impl<nested_begin_end_tag> { template< typename Sequence > struct apply { typedef typename Sequence::begin type; }; };
>template<> struct end_impl<nested_begin_end_tag> { template< typename Sequence > struct apply { typedef typename Sequence::end type; }; };
>
>
>
>
>template<> struct begin_impl<non_sequence_tag> { template< typename Sequence > struct apply { typedef void_ type; }; };
>template<> struct end_impl<non_sequence_tag> { template< typename Sequence > struct apply { typedef void_ type; }; };
>template<> struct begin_impl<na> { template< typename Sequence > struct apply { typedef void_ type; }; };
>template<> struct end_impl<na> { template< typename Sequence > struct apply { typedef void_ type; }; };
>
>
>
>
>
>
>
>}}
># 19 "/usr/include/boost/mpl/begin_end.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/sequence_tag.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/sequence_tag.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/has_tag.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/has_tag.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_tag { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper const volatile* , boost::mpl::aux::type_wrapper<typename U::tag>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
>}}}
># 19 "/usr/include/boost/mpl/sequence_tag.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost { namespace mpl {
># 78 "/usr/include/boost/mpl/sequence_tag.hpp" 3 4
>namespace aux {
>
>template< bool has_tag_, bool has_begin_ >
>struct sequence_tag_impl
>{
>
>
> template< typename Sequence > struct result2_;
>};
># 98 "/usr/include/boost/mpl/sequence_tag.hpp" 3 4
>template<> struct sequence_tag_impl<true,true> { template< typename Sequence > struct result2_ { typedef typename Sequence::tag type; }; };
>template<> struct sequence_tag_impl<true,false> { template< typename Sequence > struct result2_ { typedef typename Sequence::tag type; }; };
>template<> struct sequence_tag_impl<false,true> { template< typename Sequence > struct result2_ { typedef nested_begin_end_tag type; }; };
>template<> struct sequence_tag_impl<false,false> { template< typename Sequence > struct result2_ { typedef non_sequence_tag type; }; };
>
>
>
>}
>
>template<
> typename Sequence = na
> >
>struct sequence_tag
> : aux::sequence_tag_impl<
> ::boost::mpl::aux::has_tag<Sequence>::value
> , ::boost::mpl::aux::has_begin<Sequence>::value
> >::template result2_<Sequence>
>{
>};
>
>
>
>template<> struct sequence_tag< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : sequence_tag< T1 > { }; }; template< typename Tag > struct lambda< sequence_tag< na > , Tag , int_<-1> > { typedef false_ is_le; typedef sequence_tag< na > result_; typedef sequence_tag< na > type; }; namespace aux { template< typename T1 > struct template_arity< sequence_tag< T1 > > : int_<1> { }; template<> struct template_arity< sequence_tag< na > > : int_<-1> { }; }
>
>}}
># 20 "/usr/include/boost/mpl/begin_end.hpp" 2 3 4
>
>
>
>namespace boost { namespace mpl {
>
>
>
>
>template<
> typename Sequence = na
> >
>struct begin
>{
> typedef typename sequence_tag<Sequence>::type tag_;
> typedef typename begin_impl< tag_ >
> ::template apply< Sequence >::type type;
>
> 
>};
>
>template<
> typename Sequence = na
> >
>struct end
>{
> typedef typename sequence_tag<Sequence>::type tag_;
> typedef typename end_impl< tag_ >
> ::template apply< Sequence >::type type;
>
> 
>};
>
>template<> struct begin< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : begin< T1 > { }; }; template< typename Tag > struct lambda< begin< na > , Tag , int_<-1> > { typedef false_ is_le; typedef begin< na > result_; typedef begin< na > type; }; namespace aux { template< typename T1 > struct template_arity< begin< T1 > > : int_<1> { }; template<> struct template_arity< begin< na > > : int_<-1> { }; }
>template<> struct end< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : end< T1 > { }; }; template< typename Tag > struct lambda< end< na > , Tag , int_<-1> > { typedef false_ is_le; typedef end< na > result_; typedef end< na > type; }; namespace aux { template< typename T1 > struct template_arity< end< T1 > > : int_<1> { }; template<> struct template_arity< end< na > > : int_<-1> { }; }
>
>}}
># 18 "/usr/include/boost/mpl/aux_/at_impl.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/advance.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/advance.hpp" 3 4
># 1 "/usr/include/boost/mpl/advance_fwd.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/advance_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>
>
>template< typename Tag > struct advance_impl;
>template< typename Iterator, typename N > struct advance;
>
>}}
># 18 "/usr/include/boost/mpl/advance.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/less.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/less.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
># 27 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/numeric_cast.hpp" 1 3 4
># 30 "/usr/include/boost/mpl/numeric_cast.hpp" 3 4
>namespace boost { namespace mpl {
>
>
>
>template< typename SourceTag, typename TargetTag > struct numeric_cast
>{
> template< typename N > struct apply;
>};
>
>}}
># 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/tag.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/tag.hpp" 3 4
>namespace boost { namespace mpl {
>
>namespace aux {
>template< typename T > struct tag_impl
>{
> typedef typename T::tag type;
>};
>}
>
>template< typename T, typename Default = void_ > struct tag
>
> : if_<
> aux::has_tag<T>
> , aux::tag_impl<T>
> , Default
> >::type
>{
># 48 "/usr/include/boost/mpl/tag.hpp" 3 4
>};
>
>}}
># 25 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/forwarding.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 2 3 4
>
>namespace boost { namespace mpl { namespace aux {
>
>template<
> typename F
> , typename Tag1
> , typename Tag2
> >
>struct cast1st_impl
>{
> template< typename N1, typename N2 > struct apply
>
> : apply_wrap2<
> F
> , typename apply_wrap1< numeric_cast<Tag1,Tag2>,N1 >::type
> , N2
> >
> {
># 46 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 3 4
> };
>};
>
>template<
> typename F
> , typename Tag1
> , typename Tag2
> >
>struct cast2nd_impl
>{
> template< typename N1, typename N2 > struct apply
>
> : apply_wrap2<
> F
> , N1
> , typename apply_wrap1< numeric_cast<Tag2,Tag1>,N2 >::type
> >
> {
># 72 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 3 4
> };
>};
>
>}}}
># 26 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
># 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/less.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/less.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename Tag1
> , typename Tag2
> >
>struct less_impl
> : if_c<
> ( Tag1::value
> > Tag2::value
> )
>
> , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 >
> , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 >
> >::type
>{
>};
>
>
>template<> struct less_impl< na,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct less_impl< na,Tag >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct less_impl< Tag,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename T > struct less_tag
>{
> typedef typename T::tag type;
>};
>
>template<
> typename N1 = na
> , typename N2 = na
> >
>struct less
>
> : less_impl<
> typename less_tag<N1>::type
> , typename less_tag<N2>::type
> >::template apply< N1,N2 >::type
>{
> 
>
>};
>
>template<> struct less< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : less< T1 , T2 > { }; }; template< typename Tag > struct lambda< less< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef less< na , na > result_; typedef less< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< less< T1 , T2 > > : int_<2> { }; template<> struct template_arity< less< na , na > > : int_<-1> { }; }
>
>}}
>
>namespace boost { namespace mpl {
>
>template<>
>struct less_impl< integral_c_tag,integral_c_tag >
>{
> template< typename N1, typename N2 > struct apply
>
> : bool_< ( N2::value > N1::value ) >
> {
> };
>};
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
># 20 "/usr/include/boost/mpl/less.hpp" 2 3 4
># 19 "/usr/include/boost/mpl/advance.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/negate.hpp" 1 3 4
># 25 "/usr/include/boost/mpl/negate.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct negate_impl;
>
>template< typename T > struct negate_tag
>{
> typedef typename T::tag type;
>};
>
>template<
> typename N = na
> >
>struct negate
>
> : negate_impl<
> typename negate_tag<N>::type
> >::template apply<N>::type
>
>
>
>
>
>
>{
> 
>};
>
>template<> struct negate< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : negate< T1 > { }; }; template< typename Tag > struct lambda< negate< na > , Tag , int_<-1> > { typedef false_ is_le; typedef negate< na > result_; typedef negate< na > type; }; namespace aux { template< typename T1 > struct template_arity< negate< T1 > > : int_<1> { }; template<> struct template_arity< negate< na > > : int_<-1> { }; }
># 65 "/usr/include/boost/mpl/negate.hpp" 3 4
>template<>
>struct negate_impl<integral_c_tag>
>{
>
>
>
>
> template< typename N > struct apply
> : integral_c< typename N::value_type, (-N::value) >
>
> {
> };
>};
>
>}}
># 20 "/usr/include/boost/mpl/advance.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/long.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/long.hpp" 3 4
># 1 "/usr/include/boost/mpl/long_fwd.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/long_fwd.hpp" 3 4
>namespace mpl_ {
>
>template< long N > struct long_;
>
>}
>namespace boost { namespace mpl { using ::mpl_::long_; } }
># 18 "/usr/include/boost/mpl/long.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
># 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
>namespace mpl_ {
>
>template< long N >
>struct long_
>{
> static const long value = N;
>
>
>
>
>
> typedef long_ type;
>
> typedef long value_type;
> typedef integral_c_tag tag;
># 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
> typedef mpl_::long_< static_cast<long>((value + 1)) > next;
> typedef mpl_::long_< static_cast<long>((value - 1)) > prior;
>
>
>
>
>
>
> operator long() const { return static_cast<long>(this->value); }
>};
>
>
>template< long N >
>long const mpl_::long_< N >::value;
>
>
>}
># 21 "/usr/include/boost/mpl/long.hpp" 2 3 4
># 21 "/usr/include/boost/mpl/advance.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
># 24 "/usr/include/boost/mpl/advance.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/aux_/advance_forward.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
># 24 "/usr/include/boost/mpl/aux_/advance_forward.hpp" 2 3 4
># 32 "/usr/include/boost/mpl/aux_/advance_forward.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>template< long N > struct advance_forward;
>template<>
>struct advance_forward<0>
>{
> template< typename Iterator > struct apply
> {
> typedef Iterator iter0;
> typedef iter0 type;
> };
>};
>
>template<>
>struct advance_forward<1>
>{
> template< typename Iterator > struct apply
> {
> typedef Iterator iter0;
> typedef typename next<iter0>::type iter1;
> typedef iter1 type;
> };
>};
>
>template<>
>struct advance_forward<2>
>{
> template< typename Iterator > struct apply
> {
> typedef Iterator iter0;
> typedef typename next<iter0>::type iter1;
> typedef typename next<iter1>::type iter2;
> typedef iter2 type;
> };
>};
>
>template<>
>struct advance_forward<3>
>{
> template< typename Iterator > struct apply
> {
> typedef Iterator iter0;
> typedef typename next<iter0>::type iter1;
> typedef typename next<iter1>::type iter2;
> typedef typename next<iter2>::type iter3;
> typedef iter3 type;
> };
>};
>
>template<>
>struct advance_forward<4>
>{
> template< typename Iterator > struct apply
> {
> typedef Iterator iter0;
> typedef typename next<iter0>::type iter1;
> typedef typename next<iter1>::type iter2;
> typedef typename next<iter2>::type iter3;
> typedef typename next<iter3>::type iter4;
> typedef iter4 type;
> };
>};
>
>template< long N >
>struct advance_forward
>{
> template< typename Iterator > struct apply
> {
> typedef typename apply_wrap1<
> advance_forward<4>
> , Iterator
> >::type chunk_result_;
>
> typedef typename apply_wrap1<
> advance_forward<(
> (N - 4) < 0
> ? 0
> : N - 4
> )>
> , chunk_result_
> >::type type;
> };
>};
>
>}}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 33 "/usr/include/boost/mpl/aux_/advance_forward.hpp" 2 3 4
># 25 "/usr/include/boost/mpl/advance.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/aux_/advance_backward.hpp" 3 4
># 1 "/usr/include/boost/mpl/prior.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/aux_/advance_backward.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
># 24 "/usr/include/boost/mpl/aux_/advance_backward.hpp" 2 3 4
># 32 "/usr/include/boost/mpl/aux_/advance_backward.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>template< long N > struct advance_backward;
>template<>
>struct advance_backward<0>
>{
> template< typename Iterator > struct apply
> {
> typedef Iterator iter0;
> typedef iter0 type;
> };
>};
>
>template<>
>struct advance_backward<1>
>{
> template< typename Iterator > struct apply
> {
> typedef Iterator iter0;
> typedef typename prior<iter0>::type iter1;
> typedef iter1 type;
> };
>};
>
>template<>
>struct advance_backward<2>
>{
> template< typename Iterator > struct apply
> {
> typedef Iterator iter0;
> typedef typename prior<iter0>::type iter1;
> typedef typename prior<iter1>::type iter2;
> typedef iter2 type;
> };
>};
>
>template<>
>struct advance_backward<3>
>{
> template< typename Iterator > struct apply
> {
> typedef Iterator iter0;
> typedef typename prior<iter0>::type iter1;
> typedef typename prior<iter1>::type iter2;
> typedef typename prior<iter2>::type iter3;
> typedef iter3 type;
> };
>};
>
>template<>
>struct advance_backward<4>
>{
> template< typename Iterator > struct apply
> {
> typedef Iterator iter0;
> typedef typename prior<iter0>::type iter1;
> typedef typename prior<iter1>::type iter2;
> typedef typename prior<iter2>::type iter3;
> typedef typename prior<iter3>::type iter4;
> typedef iter4 type;
> };
>};
>
>template< long N >
>struct advance_backward
>{
> template< typename Iterator > struct apply
> {
> typedef typename apply_wrap1<
> advance_backward<4>
> , Iterator
> >::type chunk_result_;
>
> typedef typename apply_wrap1<
> advance_backward<(
> (N - 4) < 0
> ? 0
> : N - 4
> )>
> , chunk_result_
> >::type type;
> };
>};
>
>}}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 33 "/usr/include/boost/mpl/aux_/advance_backward.hpp" 2 3 4
># 26 "/usr/include/boost/mpl/advance.hpp" 2 3 4
>
>
>
>
>namespace boost { namespace mpl {
>
>
>template< typename Tag >
>struct advance_impl
>{
> template< typename Iterator, typename N > struct apply
> {
> typedef typename less< N,long_<0> >::type backward_;
> typedef typename if_< backward_, negate<N>, N >::type offset_;
>
> typedef typename if_<
> backward_
> , aux::advance_backward< offset_::value >
> , aux::advance_forward< offset_::value >
> >::type f_;
>
> typedef typename apply_wrap1<f_,Iterator>::type type;
> };
>};
>
>
>template<
> typename Iterator = na
> , typename N = na
> >
>struct advance
> : advance_impl< typename tag<Iterator>::type >
> ::template apply<Iterator,N>
>{
>};
>
>template<
> typename Iterator
> , long N
> >
>struct advance_c
> : advance_impl< typename tag<Iterator>::type >
> ::template apply<Iterator,long_<N> >
>{
>};
>
>template<> struct advance< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : advance< T1 , T2 > { }; }; template< typename Tag > struct lambda< advance< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef advance< na , na > result_; typedef advance< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< advance< T1 , T2 > > : int_<2> { }; template<> struct template_arity< advance< na , na > > : int_<-1> { }; }
>
>}}
># 19 "/usr/include/boost/mpl/aux_/at_impl.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/deref.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/deref.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/msvc_type.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/aux_/msvc_type.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
># 48 "/usr/include/boost/mpl/aux_/msvc_type.hpp" 3 4
>template< typename T > struct msvc_type
>{
> typedef typename T::type type;
>};
>
>template<> struct msvc_type<int>
>{
> typedef int type;
>};
>
>
>
>}}}
># 18 "/usr/include/boost/mpl/deref.hpp" 2 3 4
>
>
>
>
>namespace boost { namespace mpl {
>
>template<
> typename Iterator = na
> >
>struct deref
>{
>
> typedef typename Iterator::type type;
>
>
>
> 
>};
>
>template<> struct deref< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : deref< T1 > { }; }; template< typename Tag > struct lambda< deref< na > , Tag , int_<-1> > { typedef false_ is_le; typedef deref< na > result_; typedef deref< na > type; }; namespace aux { template< typename T1 > struct template_arity< deref< T1 > > : int_<1> { }; template<> struct template_arity< deref< na > > : int_<-1> { }; }
>
>}}
># 20 "/usr/include/boost/mpl/aux_/at_impl.hpp" 2 3 4
>
>
>namespace boost { namespace mpl {
>
>
>
>
>template< typename Tag >
>struct at_impl
>{
> template< typename Sequence, typename N > struct apply
> {
> typedef typename advance<
> typename begin<Sequence>::type
> , N
> >::type iter_;
>
> typedef typename deref<iter_>::type type;
> };
>};
>
> template<> struct at_impl<non_sequence_tag> {};
>
>}}
># 19 "/usr/include/boost/mpl/at.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost { namespace mpl {
>
>template<
> typename Sequence = na
> , typename N = na
> >
>struct at
> : at_impl< typename sequence_tag<Sequence>::type >
> ::template apply< Sequence,N >
>{
> 
>};
>
>template<
> typename Sequence
> , long N
> >
>struct at_c
> : at_impl< typename sequence_tag<Sequence>::type >
> ::template apply< Sequence,mpl::long_<N> >
>{
>};
>
>template<> struct at< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : at< T1 , T2 > { }; }; template< typename Tag > struct lambda< at< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef at< na , na > result_; typedef at< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< at< T1 , T2 > > : int_<2> { }; template<> struct template_arity< at< na , na > > : int_<-1> { }; }
>
>}}
># 24 "/usr/include/boost/multi_index_container.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/contains.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/contains.hpp" 3 4
># 1 "/usr/include/boost/mpl/contains_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/contains_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct contains_impl;
>template< typename Sequence, typename T > struct contains;
>
>}}
># 19 "/usr/include/boost/mpl/contains.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/aux_/contains_impl.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/aux_/contains_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/find.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/find.hpp" 3 4
># 1 "/usr/include/boost/mpl/find_if.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/find_if.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/find_if_pred.hpp" 1 3 4
># 14 "/usr/include/boost/mpl/aux_/find_if_pred.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/iter_apply.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/iter_apply.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/iter_apply.hpp" 2 3 4
>
>
>namespace boost { namespace mpl { namespace aux {
>
>template<
> typename F
> , typename Iterator
> >
>struct iter_apply1
> : apply1< F,typename deref<Iterator>::type >
>{
>};
>
>template<
> typename F
> , typename Iterator1
> , typename Iterator2
> >
>struct iter_apply2
> : apply2<
> F
> , typename deref<Iterator1>::type
> , typename deref<Iterator2>::type
> >
>{
>};
>
>}}}
># 15 "/usr/include/boost/mpl/aux_/find_if_pred.hpp" 2 3 4
>
>
>namespace boost { namespace mpl { namespace aux {
>
>template< typename Predicate >
>struct find_if_pred
>{
> template< typename Iterator >
> struct apply
> {
> typedef not_< aux::iter_apply1<Predicate,Iterator> > type;
> };
>};
>
>}}}
># 18 "/usr/include/boost/mpl/find_if.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/find_if.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/iter_fold_if.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/iter_fold_if.hpp" 3 4
># 1 "/usr/include/boost/mpl/logical.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/iter_fold_if.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/mpl/pair.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/pair.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename T1 = na
> , typename T2 = na
> >
>struct pair
>{
> typedef pair type;
> typedef T1 first;
> typedef T2 second;
>
> 
>};
>
>template<
> typename P = na
> >
>struct first
>{
>
> typedef typename P::first type;
>
>
>
> 
>};
>
>template<
> typename P = na
> >
>struct second
>{
>
> typedef typename P::second type;
>
>
>
> 
>};
>
>
>template<> struct pair< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : pair< T1 , T2 > { }; }; template< typename Tag > struct lambda< pair< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef pair< na , na > result_; typedef pair< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< pair< T1 , T2 > > : int_<2> { }; template<> struct template_arity< pair< na , na > > : int_<-1> { }; }
>template<> struct first< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : first< T1 > { }; }; template< typename Tag > struct lambda< first< na > , Tag , int_<-1> > { typedef false_ is_le; typedef first< na > result_; typedef first< na > type; }; namespace aux { template< typename T1 > struct template_arity< first< T1 > > : int_<1> { }; template<> struct template_arity< first< na > > : int_<-1> { }; }
>template<> struct second< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : second< T1 > { }; }; template< typename Tag > struct lambda< second< na > , Tag , int_<-1> > { typedef false_ is_le; typedef second< na > result_; typedef second< na > type; }; namespace aux { template< typename T1 > struct template_arity< second< T1 > > : int_<1> { }; template<> struct template_arity< second< na > > : int_<-1> { }; }
>
>}}
># 24 "/usr/include/boost/mpl/iter_fold_if.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
># 25 "/usr/include/boost/mpl/iter_fold_if.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 2 3 4
># 32 "/usr/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp" 1 3 4
># 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>template< typename Iterator, typename State >
>struct iter_fold_if_null_step
>{
> typedef State state;
> typedef Iterator iterator;
>};
>
>template< bool >
>struct iter_fold_if_step_impl
>{
> template<
> typename Iterator
> , typename State
> , typename StateOp
> , typename IteratorOp
> >
> struct result_
> {
> typedef typename apply2< StateOp,State,Iterator >::type state;
> typedef typename IteratorOp::type iterator;
> };
>};
>
>template<>
>struct iter_fold_if_step_impl<false>
>{
> template<
> typename Iterator
> , typename State
> , typename StateOp
> , typename IteratorOp
> >
> struct result_
> {
> typedef State state;
> typedef Iterator iterator;
> };
>};
>
>template<
> typename Iterator
> , typename State
> , typename ForwardOp
> , typename Predicate
> >
>struct iter_fold_if_forward_step
>{
> typedef typename apply2< Predicate,State,Iterator >::type not_last;
> typedef typename iter_fold_if_step_impl<
> not_last::value
> >::template result_< Iterator,State,ForwardOp, mpl::next<Iterator> > impl_;
>
> typedef typename impl_::state state;
> typedef typename impl_::iterator iterator;
>};
>
>template<
> typename Iterator
> , typename State
> , typename BackwardOp
> , typename Predicate
> >
>struct iter_fold_if_backward_step
>{
> typedef typename apply2< Predicate,State,Iterator >::type not_last;
> typedef typename iter_fold_if_step_impl<
> not_last::value
> >::template result_< Iterator,State,BackwardOp, identity<Iterator> > impl_;
>
> typedef typename impl_::state state;
> typedef typename impl_::iterator iterator;
>};
>
>template<
> typename Iterator
> , typename State
> , typename ForwardOp
> , typename ForwardPredicate
> , typename BackwardOp
> , typename BackwardPredicate
> >
>struct iter_fold_if_impl
>{
> private:
> typedef iter_fold_if_null_step< Iterator,State > forward_step0;
> typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1;
> typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2;
> typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3;
> typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4;
>
>
> typedef typename if_<
> typename forward_step4::not_last
> , iter_fold_if_impl<
> typename forward_step4::iterator
> , typename forward_step4::state
> , ForwardOp
> , ForwardPredicate
> , BackwardOp
> , BackwardPredicate
> >
> , iter_fold_if_null_step<
> typename forward_step4::iterator
> , typename forward_step4::state
> >
> >::type backward_step4;
>
> typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3;
> typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2;
> typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1;
> typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0;
>
>
> public:
> typedef typename backward_step0::state state;
> typedef typename backward_step4::iterator iterator;
>};
>
>}}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 33 "/usr/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 2 3 4
># 26 "/usr/include/boost/mpl/iter_fold_if.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost { namespace mpl {
>
>namespace aux {
>
>template< typename Predicate, typename LastIterator >
>struct iter_fold_if_pred
>{
> template< typename State, typename Iterator > struct apply
>
> : and_<
> not_< is_same<Iterator,LastIterator> >
> , apply1<Predicate,Iterator>
> >
> {
>
>
>
>
>
>
>
> };
>};
>
>}
>
>template<
> typename Sequence = na
> , typename State = na
> , typename ForwardOp = na
> , typename ForwardPredicate = na
> , typename BackwardOp = na
> , typename BackwardPredicate = na
> >
>struct iter_fold_if
>{
>
> typedef typename begin<Sequence>::type first_;
> typedef typename end<Sequence>::type last_;
>
> typedef typename eval_if<
> is_na<BackwardPredicate>
> , if_< is_na<BackwardOp>, always<false_>, always<true_> >
> , identity<BackwardPredicate>
> >::type backward_pred_;
>
>
>
> struct result_ :
>
>
>
> aux::iter_fold_if_impl<
> first_
> , State
> , ForwardOp
> , protect< aux::iter_fold_if_pred< ForwardPredicate,last_ > >
> , BackwardOp
> , backward_pred_
> >
>
> { };
>
>
>
>
>public:
>
> typedef pair<
> typename result_::state
> , typename result_::iterator
> > type;
>
> 
>
>
>
>
>};
>
>template<> struct iter_fold_if< na , na , na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct apply : iter_fold_if< T1 , T2 , T3 , T4 , T5 , T6 > { }; }; template< typename Tag > struct lambda< iter_fold_if< na , na , na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iter_fold_if< na , na , na , na , na , na > result_; typedef iter_fold_if< na , na , na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct template_arity< iter_fold_if< T1 , T2 , T3 , T4 , T5 , T6 > > : int_<6> { }; template<> struct template_arity< iter_fold_if< na , na , na , na , na , na > > : int_<-1> { }; }
>
>}}
># 20 "/usr/include/boost/mpl/find_if.hpp" 2 3 4
>
>
>
>
>namespace boost { namespace mpl {
>
>
>
>template<
> typename Sequence = na
> , typename Predicate = na
> >
>struct find_if
>{
> typedef typename iter_fold_if<
> Sequence
> , void
> , mpl::arg<1>
> , protect< aux::find_if_pred<Predicate> >
> >::type result_;
>
> typedef typename second<result_>::type type;
>
> 
>};
>
>template<> struct find_if< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : find_if< T1 , T2 > { }; }; template< typename Tag > struct lambda< find_if< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef find_if< na , na > result_; typedef find_if< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< find_if< T1 , T2 > > : int_<2> { }; template<> struct template_arity< find_if< na , na > > : int_<-1> { }; }
>
>}}
># 18 "/usr/include/boost/mpl/find.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/same_as.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/same_as.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/lambda_spec.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/same_as.hpp" 2 3 4
>
>
>
>
>namespace boost { namespace mpl {
>
>template< typename T1 >
>struct same_as
>{
> template< typename T2 > struct apply
>
> : is_same<T1,T2>
> {
>
>
>
>
> };
>};
>
>template< typename T1 >
>struct not_same_as
>{
> template< typename T2 > struct apply
>
> : not_< is_same<T1,T2> >
> {
>
>
>
>
> };
>};
>
>}}
># 19 "/usr/include/boost/mpl/find.hpp" 2 3 4
>
>
>
>namespace boost { namespace mpl {
>
>template<
> typename Sequence = na
> , typename T = na
> >
>struct find
> : find_if< Sequence,same_as<T> >
>{
> 
>};
>
>template<> struct find< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : find< T1 , T2 > { }; }; template< typename Tag > struct lambda< find< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef find< na , na > result_; typedef find< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< find< T1 , T2 > > : int_<2> { }; template<> struct template_arity< find< na , na > > : int_<-1> { }; }
>
>}}
># 21 "/usr/include/boost/mpl/aux_/contains_impl.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost { namespace mpl {
>
>template< typename Tag >
>struct contains_impl
>{
> template< typename Sequence, typename T > struct apply
>
> : not_< is_same<
> typename find<Sequence,T>::type
> , typename end<Sequence>::type
> > >
> {
># 54 "/usr/include/boost/mpl/aux_/contains_impl.hpp" 3 4
> };
>};
>
> template<> struct contains_impl<non_sequence_tag> {};
>
>}}
># 21 "/usr/include/boost/mpl/contains.hpp" 2 3 4
>
>
>
>namespace boost { namespace mpl {
>
>template<
> typename Sequence = na
> , typename T = na
> >
>struct contains
> : contains_impl< typename sequence_tag<Sequence>::type >
> ::template apply< Sequence,T >
>{
> 
>};
>
>template<> struct contains< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : contains< T1 , T2 > { }; }; template< typename Tag > struct lambda< contains< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef contains< na , na > result_; typedef contains< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< contains< T1 , T2 > > : int_<2> { }; template<> struct template_arity< contains< na , na > > : int_<-1> { }; }
>
>}}
># 25 "/usr/include/boost/multi_index_container.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/mpl/size.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/size.hpp" 3 4
># 1 "/usr/include/boost/mpl/size_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/size_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct size_impl;
>template< typename Sequence > struct size;
>
>}}
># 18 "/usr/include/boost/mpl/size.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/aux_/size_impl.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/size_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/distance.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/distance.hpp" 3 4
># 1 "/usr/include/boost/mpl/distance_fwd.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/distance_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>
>
>template< typename Tag > struct distance_impl;
>template< typename First, typename Last > struct distance;
>
>}}
># 18 "/usr/include/boost/mpl/distance.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/iter_fold.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/iter_fold.hpp" 3 4
># 1 "/usr/include/boost/mpl/O1_size.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/O1_size.hpp" 3 4
># 1 "/usr/include/boost/mpl/O1_size_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/O1_size_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct O1_size_impl;
>template< typename Sequence > struct O1_size;
>
>}}
># 18 "/usr/include/boost/mpl/O1_size.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/has_size.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/has_size.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_size { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper const volatile* , boost::mpl::aux::type_wrapper<typename U::size>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
>}}}
># 21 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 2 3 4
>
>
>
>
>
>namespace boost { namespace mpl {
># 35 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 3 4
>namespace aux {
>template< typename Sequence > struct O1_size_impl
> : Sequence::size
>{
>};
>}
>
>template< typename Tag >
>struct O1_size_impl
>{
> template< typename Sequence > struct apply
>
> : if_<
> aux::has_size<Sequence>
> , aux::O1_size_impl<Sequence>
> , long_<-1>
> >::type
> {
># 69 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 3 4
> };
>};
># 85 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 3 4
>}}
># 20 "/usr/include/boost/mpl/O1_size.hpp" 2 3 4
>
>
>
>namespace boost { namespace mpl {
>
>
>template<
> typename Sequence = na
> >
>struct O1_size
> : O1_size_impl< typename sequence_tag<Sequence>::type >
> ::template apply< Sequence >
>{
> 
>};
>
>template<> struct O1_size< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : O1_size< T1 > { }; }; template< typename Tag > struct lambda< O1_size< na > , Tag , int_<-1> > { typedef false_ is_le; typedef O1_size< na > result_; typedef O1_size< na > type; }; namespace aux { template< typename T1 > struct template_arity< O1_size< T1 > > : int_<1> { }; template<> struct template_arity< O1_size< na > > : int_<-1> { }; }
>
>}}
># 20 "/usr/include/boost/mpl/iter_fold.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/aux_/iter_fold_impl.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/iter_fold_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/aux_/iter_fold_impl.hpp" 2 3 4
># 33 "/usr/include/boost/mpl/aux_/iter_fold_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>
>
>template<
> int N
> , typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct iter_fold_impl;
>
>template<
> typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct iter_fold_impl< 0,First,Last,State,ForwardOp >
>{
> typedef First iter0;
> typedef State state0;
> typedef state0 state;
> typedef iter0 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct iter_fold_impl< 1,First,Last,State,ForwardOp >
>{
> typedef First iter0;
> typedef State state0;
> typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
> typedef typename mpl::next<iter0>::type iter1;
>
>
> typedef state1 state;
> typedef iter1 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct iter_fold_impl< 2,First,Last,State,ForwardOp >
>{
> typedef First iter0;
> typedef State state0;
> typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
> typedef typename mpl::next<iter0>::type iter1;
> typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
> typedef typename mpl::next<iter1>::type iter2;
>
>
> typedef state2 state;
> typedef iter2 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct iter_fold_impl< 3,First,Last,State,ForwardOp >
>{
> typedef First iter0;
> typedef State state0;
> typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
> typedef typename mpl::next<iter0>::type iter1;
> typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
> typedef typename mpl::next<iter1>::type iter2;
> typedef typename apply2< ForwardOp,state2,iter2 >::type state3;
> typedef typename mpl::next<iter2>::type iter3;
>
>
> typedef state3 state;
> typedef iter3 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct iter_fold_impl< 4,First,Last,State,ForwardOp >
>{
> typedef First iter0;
> typedef State state0;
> typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
> typedef typename mpl::next<iter0>::type iter1;
> typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
> typedef typename mpl::next<iter1>::type iter2;
> typedef typename apply2< ForwardOp,state2,iter2 >::type state3;
> typedef typename mpl::next<iter2>::type iter3;
> typedef typename apply2< ForwardOp,state3,iter3 >::type state4;
> typedef typename mpl::next<iter3>::type iter4;
>
>
> typedef state4 state;
> typedef iter4 iterator;
>};
>
>template<
> int N
> , typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct iter_fold_impl
>{
> typedef iter_fold_impl<
> 4
> , First
> , Last
> , State
> , ForwardOp
> > chunk_;
>
> typedef iter_fold_impl<
> ( (N - 4) < 0 ? 0 : N - 4 )
> , typename chunk_::iterator
> , Last
> , typename chunk_::state
> , ForwardOp
> > res_;
>
> typedef typename res_::state state;
> typedef typename res_::iterator iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct iter_fold_impl< -1,First,Last,State,ForwardOp >
> : iter_fold_impl<
> -1
> , typename mpl::next<First>::type
> , Last
> , typename apply2< ForwardOp,State,First >::type
> , ForwardOp
> >
>{
>};
>
>template<
> typename Last
> , typename State
> , typename ForwardOp
> >
>struct iter_fold_impl< -1,Last,Last,State,ForwardOp >
>{
> typedef State state;
> typedef Last iterator;
>};
>
>}}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 34 "/usr/include/boost/mpl/aux_/iter_fold_impl.hpp" 2 3 4
># 22 "/usr/include/boost/mpl/iter_fold.hpp" 2 3 4
>
>
>
>namespace boost { namespace mpl {
>
>template<
> typename Sequence = na
> , typename State = na
> , typename ForwardOp = na
> >
>struct iter_fold
>{
> typedef typename aux::iter_fold_impl<
> ::boost::mpl::O1_size<Sequence>::value
> , typename begin<Sequence>::type
> , typename end<Sequence>::type
> , State
> , typename lambda<ForwardOp>::type
> >::state type;
>
> 
>};
>
>template<> struct iter_fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : iter_fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< iter_fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iter_fold< na , na , na > result_; typedef iter_fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< iter_fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< iter_fold< na , na , na > > : int_<-1> { }; }
>
>}}
># 19 "/usr/include/boost/mpl/distance.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/iterator_range.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/iterator_range.hpp" 3 4
>namespace boost { namespace mpl {
>
>struct iterator_range_tag;
>
>template<
> typename First = na
> , typename Last = na
> >
>struct iterator_range
>{
> typedef iterator_range_tag tag;
> typedef iterator_range type;
> typedef First begin;
> typedef Last end;
>
> 
>};
>
>template<> struct iterator_range< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : iterator_range< T1 , T2 > { }; }; template< typename Tag > struct lambda< iterator_range< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iterator_range< na , na > result_; typedef iterator_range< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< iterator_range< T1 , T2 > > : int_<2> { }; template<> struct template_arity< iterator_range< na , na > > : int_<-1> { }; }
>
>}}
># 20 "/usr/include/boost/mpl/distance.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
># 24 "/usr/include/boost/mpl/distance.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost { namespace mpl {
>
>
>template< typename Tag > struct distance_impl
>{
> template< typename First, typename Last > struct apply
>
> : aux::msvc_eti_base< typename iter_fold<
> iterator_range<First,Last>
> , mpl::long_<0>
> , next<>
> >::type >
> {
># 60 "/usr/include/boost/mpl/distance.hpp" 3 4
> };
>};
>
>template<
> typename First = na
> , typename Last = na
> >
>struct distance
> : distance_impl< typename tag<First>::type >
> ::template apply<First, Last>
>{
> 
>};
>
>template<> struct distance< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : distance< T1 , T2 > { }; }; template< typename Tag > struct lambda< distance< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef distance< na , na > result_; typedef distance< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< distance< T1 , T2 > > : int_<2> { }; template<> struct template_arity< distance< na , na > > : int_<-1> { }; }
>
>}}
># 20 "/usr/include/boost/mpl/aux_/size_impl.hpp" 2 3 4
>
>
>
>namespace boost { namespace mpl {
>
>
>
>
>template< typename Tag >
>struct size_impl
>{
> template< typename Sequence > struct apply
>
> : distance<
> typename begin<Sequence>::type
> , typename end<Sequence>::type
> >
> {
>
>
>
>
>
>
>
> };
>};
>
> template<> struct size_impl<non_sequence_tag> {};
>
>}}
># 20 "/usr/include/boost/mpl/size.hpp" 2 3 4
>
>
>
>
>namespace boost { namespace mpl {
>
>template<
> typename Sequence = na
> >
>struct size
> : aux::msvc_eti_base<
> typename size_impl< typename sequence_tag<Sequence>::type >
> ::template apply< Sequence >::type
> >::type
>{
> 
>};
>
>template<> struct size< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : size< T1 > { }; }; template< typename Tag > struct lambda< size< na > , Tag , int_<-1> > { typedef false_ is_le; typedef size< na > result_; typedef size< na > type; }; namespace aux { template< typename T1 > struct template_arity< size< T1 > > : int_<1> { }; template<> struct template_arity< size< na > > : int_<-1> { }; }
>
>}}
># 29 "/usr/include/boost/multi_index_container.hpp" 2 3 4
>
># 1 "/usr/include/boost/multi_index_container_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/multi_index_container_fwd.hpp" 3 4
># 1 "/usr/include/boost/multi_index/identity.hpp" 1 3 4
># 18 "/usr/include/boost/multi_index/identity.hpp" 3 4
># 1 "/usr/include/boost/multi_index/identity_fwd.hpp" 1 3 4
># 16 "/usr/include/boost/multi_index/identity_fwd.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>template<class Type> struct identity;
>
>}
>
>}
># 19 "/usr/include/boost/multi_index/identity.hpp" 2 3 4
># 27 "/usr/include/boost/multi_index/identity.hpp" 3 4
>namespace boost{
>
>template<class Type> class reference_wrapper;
>
>namespace multi_index{
>
>namespace detail{
># 55 "/usr/include/boost/multi_index/identity.hpp" 3 4
>template<typename Type>
>struct const_identity_base
>{
> typedef Type result_type;
>
> template<typename ChainedPtr>
>
>
> typename disable_if<is_convertible<const ChainedPtr&,Type&>,Type&>::type
>
>
>
>
> operator()(const ChainedPtr& x)const
> {
> return operator()(*x);
> }
>
> Type& operator()(Type& x)const
> {
> return x;
> }
>
> Type& operator()(const reference_wrapper<Type>& x)const
> {
> return x.get();
> }
>
> Type& operator()(
> const reference_wrapper<typename remove_const<Type>::type>& x,int=0)const
> {
> return x.get();
> }
>};
>
>template<typename Type>
>struct non_const_identity_base
>{
> typedef Type result_type;
>
>
>
> template<typename ChainedPtr>
>
>
> typename disable_if<
> is_convertible<const ChainedPtr&,const Type&>,Type&>::type
>
>
>
>
> operator()(const ChainedPtr& x)const
> {
> return operator()(*x);
> }
>
> const Type& operator()(const Type& x,int=0)const
> {
> return x;
> }
>
> Type& operator()(Type& x)const
> {
> return x;
> }
>
> const Type& operator()(const reference_wrapper<const Type>& x,int=0)const
> {
> return x.get();
> }
>
> Type& operator()(const reference_wrapper<Type>& x)const
> {
> return x.get();
> }
>};
>
>}
>
>template<class Type>
>struct identity:
> mpl::if_c<
> is_const<Type>::value,
> detail::const_identity_base<Type>,detail::non_const_identity_base<Type>
> >::type
>{
>};
>
>}
>
>}
># 18 "/usr/include/boost/multi_index_container_fwd.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/indexed_by.hpp" 1 3 4
># 17 "/usr/include/boost/multi_index/indexed_by.hpp" 3 4
># 1 "/usr/include/boost/mpl/vector.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/vector.hpp" 3 4
># 1 "/usr/include/boost/mpl/limits/vector.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/vector.hpp" 2 3 4
># 36 "/usr/include/boost/mpl/vector.hpp" 3 4
># 1 "/usr/include/boost/mpl/vector/vector20.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/vector/vector20.hpp" 3 4
># 1 "/usr/include/boost/mpl/vector/vector10.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/vector/vector10.hpp" 3 4
># 1 "/usr/include/boost/mpl/vector/vector0.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/vector/vector0.hpp" 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/at.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/vector/aux_/at.hpp" 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/tag.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/vector/aux_/tag.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/typeof.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/vector/aux_/tag.hpp" 2 3 4
>
>
>namespace boost { namespace mpl { namespace aux {
>
>struct v_iter_tag;
>
>
>struct vector_tag;
>
>
>
>
>}}}
># 19 "/usr/include/boost/mpl/vector/aux_/at.hpp" 2 3 4
># 27 "/usr/include/boost/mpl/vector/aux_/at.hpp" 3 4
>namespace boost { namespace mpl {
>
>
>
>template< typename Vector, long n_ >
>struct v_at_impl
>{
> typedef long_< (Vector::lower_bound_::value + n_) > index_;
> typedef __typeof__( Vector::item_(index_()) ) type;
>};
>
>
>template< typename Vector, long n_ >
>struct v_at
> : aux::wrapped_type< typename v_at_impl<Vector,n_>::type >
>{
>};
>
>template<>
>struct at_impl< aux::vector_tag >
>{
> template< typename Vector, typename N > struct apply
> : v_at<
> Vector
> , N::value
> >
> {
> };
>};
># 114 "/usr/include/boost/mpl/vector/aux_/at.hpp" 3 4
>}}
># 18 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/front.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/vector/aux_/front.hpp" 3 4
># 1 "/usr/include/boost/mpl/front_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/front_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct front_impl;
>template< typename Sequence > struct front;
>
>}}
># 18 "/usr/include/boost/mpl/vector/aux_/front.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost { namespace mpl {
>
>
>
>template<>
>struct front_impl< aux::vector_tag >
>{
> template< typename Vector > struct apply
> : v_at<Vector,0>
> {
> };
>};
># 54 "/usr/include/boost/mpl/vector/aux_/front.hpp" 3 4
>}}
># 19 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/push_front.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/vector/aux_/push_front.hpp" 3 4
># 1 "/usr/include/boost/mpl/push_front_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/push_front_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct push_front_impl;
>template< typename Sequence, typename T > struct push_front;
>
>}}
># 18 "/usr/include/boost/mpl/vector/aux_/push_front.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/mpl/vector/aux_/item.hpp" 1 3 4
># 24 "/usr/include/boost/mpl/vector/aux_/item.hpp" 3 4
>namespace boost { namespace mpl {
>
>
>
>template<
> typename T
> , typename Base
> , int at_front = 0
> >
>struct v_item
> : Base
>{
> typedef typename Base::upper_bound_ index_;
> typedef typename next<index_>::type upper_bound_;
> typedef typename next<typename Base::size>::type size;
> typedef Base base;
> typedef v_item type;
>
>
>
> static aux::type_wrapper<T> item_(index_);
> using Base::item_;
>};
>
>template<
> typename T
> , typename Base
> >
>struct v_item<T,Base,1>
> : Base
>{
> typedef typename prior<typename Base::lower_bound_>::type index_;
> typedef index_ lower_bound_;
> typedef typename next<typename Base::size>::type size;
> typedef Base base;
> typedef v_item type;
>
> static aux::type_wrapper<T> item_(index_);
> using Base::item_;
>};
>
>
>template<
> typename Base
> , int at_front
> >
>struct v_mask
> : Base
>{
> typedef typename prior<typename Base::upper_bound_>::type index_;
> typedef index_ upper_bound_;
> typedef typename prior<typename Base::size>::type size;
> typedef Base base;
> typedef v_mask type;
>
> static aux::type_wrapper<void_> item_(index_);
> using Base::item_;
>};
>
>template<
> typename Base
> >
>struct v_mask<Base,1>
> : Base
>{
> typedef typename Base::lower_bound_ index_;
> typedef typename next<index_>::type lower_bound_;
> typedef typename prior<typename Base::size>::type size;
> typedef Base base;
> typedef v_mask type;
>
> static aux::type_wrapper<void_> item_(index_);
> using Base::item_;
>};
>
>
>
>}}
># 23 "/usr/include/boost/mpl/vector/aux_/push_front.hpp" 2 3 4
>
>
>namespace boost { namespace mpl {
>
>template<>
>struct push_front_impl< aux::vector_tag >
>{
> template< typename Vector, typename T > struct apply
> {
> typedef v_item<T,Vector,1> type;
> };
>};
>
>}}
># 20 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/pop_front.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/vector/aux_/pop_front.hpp" 3 4
># 1 "/usr/include/boost/mpl/pop_front_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/pop_front_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct pop_front_impl;
>template< typename Sequence > struct pop_front;
>
>}}
># 18 "/usr/include/boost/mpl/vector/aux_/pop_front.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost { namespace mpl {
>
>template<>
>struct pop_front_impl< aux::vector_tag >
>{
> template< typename Vector > struct apply
> {
> typedef v_mask<Vector,1> type;
> };
>};
>
>}}
># 21 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/push_back.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/vector/aux_/push_back.hpp" 3 4
># 1 "/usr/include/boost/mpl/push_back_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/push_back_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct push_back_impl;
>template< typename Sequence, typename T > struct push_back;
>
>}}
># 18 "/usr/include/boost/mpl/vector/aux_/push_back.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost { namespace mpl {
>
>template<>
>struct push_back_impl< aux::vector_tag >
>{
> template< typename Vector, typename T > struct apply
> {
> typedef v_item<T,Vector,0> type;
> };
>};
>
>}}
># 22 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/pop_back.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/vector/aux_/pop_back.hpp" 3 4
># 1 "/usr/include/boost/mpl/pop_back_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/pop_back_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct pop_back_impl;
>template< typename Sequence > struct pop_back;
>
>}}
># 18 "/usr/include/boost/mpl/vector/aux_/pop_back.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost { namespace mpl {
>
>template<>
>struct pop_back_impl< aux::vector_tag >
>{
> template< typename Vector > struct apply
> {
> typedef v_mask<Vector,0> type;
> };
>};
>
>}}
># 23 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/back.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/vector/aux_/back.hpp" 3 4
># 1 "/usr/include/boost/mpl/back_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/back_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct back_impl;
>template< typename Sequence > struct back;
>
>}}
># 18 "/usr/include/boost/mpl/vector/aux_/back.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost { namespace mpl {
>
>
>
>template<>
>struct back_impl< aux::vector_tag >
>{
> template< typename Vector > struct apply
> : v_at<
> Vector
> , prior<typename Vector::size>::type::value
> >
> {
> };
>};
># 57 "/usr/include/boost/mpl/vector/aux_/back.hpp" 3 4
>}}
># 24 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/clear.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/vector/aux_/clear.hpp" 3 4
># 1 "/usr/include/boost/mpl/clear_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/clear_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct clear_impl;
>template< typename Sequence > struct clear;
>
>}}
># 18 "/usr/include/boost/mpl/vector/aux_/clear.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/vector0.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/vector/aux_/vector0.hpp" 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 3 4
># 1 "/usr/include/boost/mpl/iterator_tags.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/iterator_tags.hpp" 3 4
>namespace boost { namespace mpl {
>
>struct forward_iterator_tag : int_<0> { typedef forward_iterator_tag type; };
>struct bidirectional_iterator_tag : int_<1> { typedef bidirectional_iterator_tag type; };
>struct random_access_iterator_tag : int_<2> { typedef random_access_iterator_tag type; };
>
>}}
># 19 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/plus.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/plus.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/largest_int.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/aux_/largest_int.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>template< typename T > struct integral_rank;
>
>template<> struct integral_rank<bool> : int_<1> {};
>template<> struct integral_rank<signed char> : int_<2> {};
>template<> struct integral_rank<char> : int_<3> {};
>template<> struct integral_rank<unsigned char> : int_<4> {};
>
>template<> struct integral_rank<wchar_t> : int_<5> {};
>
>template<> struct integral_rank<short> : int_<6> {};
>template<> struct integral_rank<unsigned short> : int_<7> {};
>template<> struct integral_rank<int> : int_<8> {};
>template<> struct integral_rank<unsigned int> : int_<9> {};
>template<> struct integral_rank<long> : int_<10> {};
>template<> struct integral_rank<unsigned long> : int_<11> {};
>
>
>template<> struct integral_rank<long_long_type> : int_<12> {};
>template<> struct integral_rank<ulong_long_type>: int_<13> {};
>
>
>template< typename T1, typename T2 > struct largest_int
>
> : if_c<
> ( integral_rank<T1>::value >= integral_rank<T2>::value )
> , T1
> , T2
> >
>{
>
>
>
>
>
>
>};
>
>}}}
># 19 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
># 27 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/plus.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/plus.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename Tag1
> , typename Tag2
> >
>struct plus_impl
> : if_c<
> ( Tag1::value
> > Tag2::value
> )
>
> , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 >
> , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 >
> >::type
>{
>};
>
>
>template<> struct plus_impl< na,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct plus_impl< na,Tag >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct plus_impl< Tag,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename T > struct plus_tag
>{
> typedef typename T::tag type;
>};
>
>template<
> typename N1 = na
> , typename N2 = na
> , typename N3 = na, typename N4 = na, typename N5 = na
> >
>struct plus
> : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5>
>{
> 
>
>
>
>
>};
>
>template<
> typename N1, typename N2, typename N3, typename N4
> >
>struct plus< N1,N2,N3,N4,na >
>
> : plus< plus< plus< N1,N2 >, N3>, N4>
>{
> 
>
>
>
>
>};
>
>template<
> typename N1, typename N2, typename N3
> >
>struct plus< N1,N2,N3,na,na >
>
> : plus< plus< N1,N2 >, N3>
>{
> 
>
>
>
>
>};
>
>template<
> typename N1, typename N2
> >
>struct plus< N1,N2,na,na,na >
> : plus_impl<
> typename plus_tag<N1>::type
> , typename plus_tag<N2>::type
> >::template apply< N1,N2 >::type
>{
> 
>
>
>
>
>
>};
>
>template<> struct plus< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : plus< T1 , T2 > { }; }; template< typename Tag > struct lambda< plus< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef plus< na , na > result_; typedef plus< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< plus< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< plus< na , na > > : int_<-1> { }; }
>
>}}
>
>namespace boost { namespace mpl {
>template<>
>struct plus_impl< integral_c_tag,integral_c_tag >
>{
> template< typename N1, typename N2 > struct apply
>
> : integral_c<
> typename aux::largest_int<
> typename N1::value_type
> , typename N2::value_type
> >::type
> , ( N1::value
> + N2::value
> )
> >
> {
> };
>};
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 35 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
># 20 "/usr/include/boost/mpl/plus.hpp" 2 3 4
># 20 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/minus.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/minus.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 1 3 4
># 26 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
># 27 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/minus.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/minus.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename Tag1
> , typename Tag2
> >
>struct minus_impl
> : if_c<
> ( Tag1::value
> > Tag2::value
> )
>
> , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 >
> , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 >
> >::type
>{
>};
>
>
>template<> struct minus_impl< na,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct minus_impl< na,Tag >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct minus_impl< Tag,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename T > struct minus_tag
>{
> typedef typename T::tag type;
>};
>
>template<
> typename N1 = na
> , typename N2 = na
> , typename N3 = na, typename N4 = na, typename N5 = na
> >
>struct minus
> : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5>
>{
> 
>
>
>
>
>};
>
>template<
> typename N1, typename N2, typename N3, typename N4
> >
>struct minus< N1,N2,N3,N4,na >
>
> : minus< minus< minus< N1,N2 >, N3>, N4>
>{
> 
>
>
>
>
>};
>
>template<
> typename N1, typename N2, typename N3
> >
>struct minus< N1,N2,N3,na,na >
>
> : minus< minus< N1,N2 >, N3>
>{
> 
>
>
>
>
>};
>
>template<
> typename N1, typename N2
> >
>struct minus< N1,N2,na,na,na >
> : minus_impl<
> typename minus_tag<N1>::type
> , typename minus_tag<N2>::type
> >::template apply< N1,N2 >::type
>{
> 
>
>
>
>
>
>};
>
>template<> struct minus< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : minus< T1 , T2 > { }; }; template< typename Tag > struct lambda< minus< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef minus< na , na > result_; typedef minus< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< minus< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< minus< na , na > > : int_<-1> { }; }
>
>}}
>
>namespace boost { namespace mpl {
>template<>
>struct minus_impl< integral_c_tag,integral_c_tag >
>{
> template< typename N1, typename N2 > struct apply
>
> : integral_c<
> typename aux::largest_int<
> typename N1::value_type
> , typename N2::value_type
> >::type
> , ( N1::value
> - N2::value
> )
> >
> {
> };
>};
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 35 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
># 20 "/usr/include/boost/mpl/minus.hpp" 2 3 4
># 21 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 2 3 4
># 30 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename Vector
> , long n_
> >
>struct v_iter
>{
> typedef aux::v_iter_tag tag;
> typedef random_access_iterator_tag category;
> typedef typename v_at<Vector,n_>::type type;
>
> typedef Vector vector_;
> typedef mpl::long_<n_> pos;
># 56 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 3 4
>};
>
>
>
>
>template<
> typename Vector
> , long n_
> >
>struct next< v_iter<Vector,n_> >
>{
> typedef v_iter<Vector,(n_ + 1)> type;
>};
>
>template<
> typename Vector
> , long n_
> >
>struct prior< v_iter<Vector,n_> >
>{
> typedef v_iter<Vector,(n_ - 1)> type;
>};
>
>template<
> typename Vector
> , long n_
> , typename Distance
> >
>struct advance< v_iter<Vector,n_>,Distance>
>{
> typedef v_iter<
> Vector
> , (n_ + Distance::value)
> > type;
>};
>
>template<
> typename Vector
> , long n_
> , long m_
> >
>struct distance< v_iter<Vector,n_>, v_iter<Vector,m_> >
> : mpl::long_<(m_ - n_)>
>{
>};
># 128 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 3 4
>}}
># 23 "/usr/include/boost/mpl/vector/aux_/vector0.hpp" 2 3 4
>
>
>
>namespace boost { namespace mpl {
>
>template< typename Dummy = na > struct vector0;
>
>template<> struct vector0<na>
>{
>
> typedef aux::vector_tag tag;
> typedef vector0 type;
> typedef long_<32768> lower_bound_;
> typedef lower_bound_ upper_bound_;
> typedef long_<0> size;
>
> static aux::type_wrapper<void_> item_(...);
># 48 "/usr/include/boost/mpl/vector/aux_/vector0.hpp" 3 4
>};
>
>}}
># 19 "/usr/include/boost/mpl/vector/aux_/clear.hpp" 2 3 4
>
>
>
>
>namespace boost { namespace mpl {
>
>
>
>template<>
>struct clear_impl< aux::vector_tag >
>{
> template< typename Vector > struct apply
> {
> typedef vector0<> type;
> };
>};
># 53 "/usr/include/boost/mpl/vector/aux_/clear.hpp" 3 4
>}}
># 25 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/O1_size.hpp" 1 3 4
># 24 "/usr/include/boost/mpl/vector/aux_/O1_size.hpp" 3 4
>namespace boost { namespace mpl {
>
>
>
>template<>
>struct O1_size_impl< aux::vector_tag >
>{
> template< typename Vector > struct apply
> : Vector::size
> {
> };
>};
># 54 "/usr/include/boost/mpl/vector/aux_/O1_size.hpp" 3 4
>}}
># 26 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/size.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/vector/aux_/size.hpp" 3 4
>namespace boost { namespace mpl {
>
>
>
>template<>
>struct size_impl< aux::vector_tag >
> : O1_size_impl< aux::vector_tag >
>{
>};
># 47 "/usr/include/boost/mpl/vector/aux_/size.hpp" 3 4
>}}
># 27 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/empty.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/vector/aux_/empty.hpp" 3 4
># 1 "/usr/include/boost/mpl/empty_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/empty_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct empty_impl;
>template< typename Sequence > struct empty;
>
>}}
># 18 "/usr/include/boost/mpl/vector/aux_/empty.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost { namespace mpl {
>
>
>
>template<>
>struct empty_impl< aux::vector_tag >
>{
> template< typename Vector > struct apply
> : is_same<
> typename Vector::lower_bound_
> , typename Vector::upper_bound_
> >
> {
> };
>};
># 66 "/usr/include/boost/mpl/vector/aux_/empty.hpp" 3 4
>}}
># 28 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/mpl/vector/aux_/begin_end.hpp" 1 3 4
># 25 "/usr/include/boost/mpl/vector/aux_/begin_end.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<>
>struct begin_impl< aux::vector_tag >
>{
> template< typename Vector > struct apply
> {
> typedef v_iter<Vector,0> type;
> };
>};
>
>template<>
>struct end_impl< aux::vector_tag >
>{
> template< typename Vector > struct apply
> {
> typedef v_iter<Vector,Vector::size::value> type;
> };
>};
>
>}}
># 32 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
># 19 "/usr/include/boost/mpl/vector/vector10.hpp" 2 3 4
># 27 "/usr/include/boost/mpl/vector/vector10.hpp" 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 1 3 4
># 49 "/usr/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename T0
> >
>struct vector1
> : v_item<
> T0
> , vector0< >
> >
>{
> typedef vector1 type;
>};
>
>template<
> typename T0, typename T1
> >
>struct vector2
> : v_item<
> T1
> , vector1<T0>
> >
>{
> typedef vector2 type;
>};
>
>template<
> typename T0, typename T1, typename T2
> >
>struct vector3
> : v_item<
> T2
> , vector2< T0,T1 >
> >
>{
> typedef vector3 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3
> >
>struct vector4
> : v_item<
> T3
> , vector3< T0,T1,T2 >
> >
>{
> typedef vector4 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> >
>struct vector5
> : v_item<
> T4
> , vector4< T0,T1,T2,T3 >
> >
>{
> typedef vector5 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5
> >
>struct vector6
> : v_item<
> T5
> , vector5< T0,T1,T2,T3,T4 >
> >
>{
> typedef vector6 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6
> >
>struct vector7
> : v_item<
> T6
> , vector6< T0,T1,T2,T3,T4,T5 >
> >
>{
> typedef vector7 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7
> >
>struct vector8
> : v_item<
> T7
> , vector7< T0,T1,T2,T3,T4,T5,T6 >
> >
>{
> typedef vector8 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8
> >
>struct vector9
> : v_item<
> T8
> , vector8< T0,T1,T2,T3,T4,T5,T6,T7 >
> >
>{
> typedef vector9 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> >
>struct vector10
> : v_item<
> T9
> , vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >
> >
>{
> typedef vector10 type;
>};
>
>}}
># 50 "/usr/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 2 3 4
># 28 "/usr/include/boost/mpl/vector/vector10.hpp" 2 3 4
># 19 "/usr/include/boost/mpl/vector/vector20.hpp" 2 3 4
># 27 "/usr/include/boost/mpl/vector/vector20.hpp" 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 1 3 4
># 49 "/usr/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10
> >
>struct vector11
> : v_item<
> T10
> , vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >
> >
>{
> typedef vector11 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11
> >
>struct vector12
> : v_item<
> T11
> , vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >
> >
>{
> typedef vector12 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12
> >
>struct vector13
> : v_item<
> T12
> , vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >
> >
>{
> typedef vector13 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12, typename T13
> >
>struct vector14
> : v_item<
> T13
> , vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >
> >
>{
> typedef vector14 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12, typename T13, typename T14
> >
>struct vector15
> : v_item<
> T14
> , vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >
> >
>{
> typedef vector15 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12, typename T13, typename T14
> , typename T15
> >
>struct vector16
> : v_item<
> T15
> , vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >
> >
>{
> typedef vector16 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12, typename T13, typename T14
> , typename T15, typename T16
> >
>struct vector17
> : v_item<
> T16
> , vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >
> >
>{
> typedef vector17 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12, typename T13, typename T14
> , typename T15, typename T16, typename T17
> >
>struct vector18
> : v_item<
> T17
> , vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >
> >
>{
> typedef vector18 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12, typename T13, typename T14
> , typename T15, typename T16, typename T17, typename T18
> >
>struct vector19
> : v_item<
> T18
> , vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >
> >
>{
> typedef vector19 type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12, typename T13, typename T14
> , typename T15, typename T16, typename T17, typename T18, typename T19
> >
>struct vector20
> : v_item<
> T19
> , vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >
> >
>{
> typedef vector20 type;
>};
>
>}}
># 50 "/usr/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 2 3 4
># 28 "/usr/include/boost/mpl/vector/vector20.hpp" 2 3 4
># 37 "/usr/include/boost/mpl/vector.hpp" 2 3 4
># 46 "/usr/include/boost/mpl/vector.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/vector.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/vector.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na
> , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na
> , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na
> , typename T12 = na, typename T13 = na, typename T14 = na
> , typename T15 = na, typename T16 = na, typename T17 = na
> , typename T18 = na, typename T19 = na
> >
>struct vector;
>
>template<
>
> >
>struct vector<
> na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
> , na, na, na
> >
> : vector0< >
>{
> typedef vector0< >::type type;
>};
>
>template<
> typename T0
> >
>struct vector<
> T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
> , na, na, na
> >
> : vector1<T0>
>{
> typedef typename vector1<T0>::type type;
>};
>
>template<
> typename T0, typename T1
> >
>struct vector<
> T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
> , na, na, na
> >
> : vector2< T0,T1 >
>{
> typedef typename vector2< T0,T1 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2
> >
>struct vector<
> T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na
> , na, na, na
> >
> : vector3< T0,T1,T2 >
>{
> typedef typename vector3< T0,T1,T2 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3
> >
>struct vector<
> T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na
> , na, na, na
> >
> : vector4< T0,T1,T2,T3 >
>{
> typedef typename vector4< T0,T1,T2,T3 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> >
>struct vector<
> T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na
> , na, na, na
> >
> : vector5< T0,T1,T2,T3,T4 >
>{
> typedef typename vector5< T0,T1,T2,T3,T4 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5
> >
>struct vector<
> T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na
> , na, na, na
> >
> : vector6< T0,T1,T2,T3,T4,T5 >
>{
> typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6
> >
>struct vector<
> T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na
> , na, na, na
> >
> : vector7< T0,T1,T2,T3,T4,T5,T6 >
>{
> typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7
> >
>struct vector<
> T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na
> , na, na, na
> >
> : vector8< T0,T1,T2,T3,T4,T5,T6,T7 >
>{
> typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8
> >
>struct vector<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na
> , na, na, na
> >
> : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >
>{
> typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> >
>struct vector<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na
> , na, na, na
> >
> : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >
>{
> typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10
> >
>struct vector<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na
> , na, na, na
> >
> : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >
>{
> typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11
> >
>struct vector<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na
> , na, na, na, na
> >
> : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >
>{
> typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12
> >
>struct vector<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na
> , na, na, na, na
> >
> : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >
>{
> typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12, typename T13
> >
>struct vector<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na
> , na, na, na, na
> >
> : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >
>{
> typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12, typename T13, typename T14
> >
>struct vector<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na
> , na, na, na, na
> >
> : vector15<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
> >
>{
> typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12, typename T13, typename T14
> , typename T15
> >
>struct vector<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
> , T15, na, na, na, na
> >
> : vector16<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
> , T15
> >
>{
> typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12, typename T13, typename T14
> , typename T15, typename T16
> >
>struct vector<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
> , T15, T16, na, na, na
> >
> : vector17<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
> , T15, T16
> >
>{
> typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12, typename T13, typename T14
> , typename T15, typename T16, typename T17
> >
>struct vector<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
> , T15, T16, T17, na, na
> >
> : vector18<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
> , T15, T16, T17
> >
>{
> typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type;
>};
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12, typename T13, typename T14
> , typename T15, typename T16, typename T17, typename T18
> >
>struct vector<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
> , T15, T16, T17, T18, na
> >
> : vector19<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
> , T15, T16, T17, T18
> >
>{
> typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type;
>};
>
>
>
>template<
> typename T0, typename T1, typename T2, typename T3, typename T4
> , typename T5, typename T6, typename T7, typename T8, typename T9
> , typename T10, typename T11, typename T12, typename T13, typename T14
> , typename T15, typename T16, typename T17, typename T18, typename T19
> >
>struct vector
> : vector20<
> T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
> , T15, T16, T17, T18, T19
> >
>{
> typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type;
>};
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 47 "/usr/include/boost/mpl/vector.hpp" 2 3 4
># 18 "/usr/include/boost/multi_index/indexed_by.hpp" 2 3 4
>
># 1 "/usr/include/boost/preprocessor/control/expr_if.hpp" 1 3 4
># 20 "/usr/include/boost/multi_index/indexed_by.hpp" 2 3 4
># 51 "/usr/include/boost/multi_index/indexed_by.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>template<
> typename T0 , typename T1 =mpl::na , typename T2 =mpl::na , typename T3 =mpl::na , typename T4 =mpl::na , typename T5 =mpl::na , typename T6 =mpl::na , typename T7 =mpl::na , typename T8 =mpl::na , typename T9 =mpl::na , typename T10 =mpl::na , typename T11 =mpl::na , typename T12 =mpl::na , typename T13 =mpl::na , typename T14 =mpl::na , typename T15 =mpl::na , typename T16 =mpl::na , typename T17 =mpl::na , typename T18 =mpl::na , typename T19 =mpl::na
>
>
>>
>struct indexed_by:
> mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19>
>{
>};
>
>}
>
>}
># 19 "/usr/include/boost/multi_index_container_fwd.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/ordered_index_fwd.hpp" 1 3 4
># 16 "/usr/include/boost/multi_index/ordered_index_fwd.hpp" 3 4
># 1 "/usr/include/boost/multi_index/detail/ord_index_args.hpp" 1 3 4
># 21 "/usr/include/boost/multi_index/detail/ord_index_args.hpp" 3 4
># 1 "/usr/include/boost/multi_index/tag.hpp" 1 3 4
># 17 "/usr/include/boost/multi_index/tag.hpp" 3 4
># 1 "/usr/include/boost/multi_index/detail/no_duplicate_tags.hpp" 1 3 4
># 17 "/usr/include/boost/multi_index/detail/no_duplicate_tags.hpp" 3 4
># 1 "/usr/include/boost/mpl/fold.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/fold.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/fold_impl.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/fold_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/aux_/fold_impl.hpp" 2 3 4
># 34 "/usr/include/boost/mpl/aux_/fold_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>
>
>template<
> int N
> , typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct fold_impl;
>
>template<
> typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct fold_impl< 0,First,Last,State,ForwardOp >
>{
> typedef First iter0;
> typedef State state0;
> typedef state0 state;
> typedef iter0 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct fold_impl< 1,First,Last,State,ForwardOp >
>{
> typedef First iter0;
> typedef State state0;
> typedef typename apply2< ForwardOp, state0, typename deref<iter0>::type >::type state1;
> typedef typename mpl::next<iter0>::type iter1;
>
>
> typedef state1 state;
> typedef iter1 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct fold_impl< 2,First,Last,State,ForwardOp >
>{
> typedef First iter0;
> typedef State state0;
> typedef typename apply2< ForwardOp, state0, typename deref<iter0>::type >::type state1;
> typedef typename mpl::next<iter0>::type iter1;
> typedef typename apply2< ForwardOp, state1, typename deref<iter1>::type >::type state2;
> typedef typename mpl::next<iter1>::type iter2;
>
>
> typedef state2 state;
> typedef iter2 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct fold_impl< 3,First,Last,State,ForwardOp >
>{
> typedef First iter0;
> typedef State state0;
> typedef typename apply2< ForwardOp, state0, typename deref<iter0>::type >::type state1;
> typedef typename mpl::next<iter0>::type iter1;
> typedef typename apply2< ForwardOp, state1, typename deref<iter1>::type >::type state2;
> typedef typename mpl::next<iter1>::type iter2;
> typedef typename apply2< ForwardOp, state2, typename deref<iter2>::type >::type state3;
> typedef typename mpl::next<iter2>::type iter3;
>
>
> typedef state3 state;
> typedef iter3 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct fold_impl< 4,First,Last,State,ForwardOp >
>{
> typedef First iter0;
> typedef State state0;
> typedef typename apply2< ForwardOp, state0, typename deref<iter0>::type >::type state1;
> typedef typename mpl::next<iter0>::type iter1;
> typedef typename apply2< ForwardOp, state1, typename deref<iter1>::type >::type state2;
> typedef typename mpl::next<iter1>::type iter2;
> typedef typename apply2< ForwardOp, state2, typename deref<iter2>::type >::type state3;
> typedef typename mpl::next<iter2>::type iter3;
> typedef typename apply2< ForwardOp, state3, typename deref<iter3>::type >::type state4;
> typedef typename mpl::next<iter3>::type iter4;
>
>
> typedef state4 state;
> typedef iter4 iterator;
>};
>
>template<
> int N
> , typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct fold_impl
>{
> typedef fold_impl<
> 4
> , First
> , Last
> , State
> , ForwardOp
> > chunk_;
>
> typedef fold_impl<
> ( (N - 4) < 0 ? 0 : N - 4 )
> , typename chunk_::iterator
> , Last
> , typename chunk_::state
> , ForwardOp
> > res_;
>
> typedef typename res_::state state;
> typedef typename res_::iterator iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename ForwardOp
> >
>struct fold_impl< -1,First,Last,State,ForwardOp >
> : fold_impl<
> -1
> , typename mpl::next<First>::type
> , Last
> , typename apply2<ForwardOp,State, typename deref<First>::type>::type
> , ForwardOp
> >
>{
>};
>
>template<
> typename Last
> , typename State
> , typename ForwardOp
> >
>struct fold_impl< -1,Last,Last,State,ForwardOp >
>{
> typedef State state;
> typedef Last iterator;
>};
>
>}}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 35 "/usr/include/boost/mpl/aux_/fold_impl.hpp" 2 3 4
># 21 "/usr/include/boost/mpl/fold.hpp" 2 3 4
>
>
>
>namespace boost { namespace mpl {
>
>template<
> typename Sequence = na
> , typename State = na
> , typename ForwardOp = na
> >
>struct fold
>{
> typedef typename aux::fold_impl<
> ::boost::mpl::O1_size<Sequence>::value
> , typename begin<Sequence>::type
> , typename end<Sequence>::type
> , State
> , ForwardOp
> >::state type;
>
> 
>};
>
>template<> struct fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef fold< na , na , na > result_; typedef fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< fold< na , na , na > > : int_<-1> { }; }
>
>}}
># 18 "/usr/include/boost/multi_index/detail/no_duplicate_tags.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/set/set0.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/set/set0.hpp" 3 4
># 1 "/usr/include/boost/mpl/set/aux_/at_impl.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/set/aux_/at_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/set/aux_/has_key_impl.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/set/aux_/has_key_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/set/aux_/tag.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/set/aux_/tag.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>struct set_tag;
>
>}}}
># 19 "/usr/include/boost/mpl/set/aux_/has_key_impl.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/has_key_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/has_key_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct has_key_impl;
>template< typename AssociativeSequence, typename Key > struct has_key;
>
>}}
># 20 "/usr/include/boost/mpl/set/aux_/has_key_impl.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/aux_/overload_names.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/overload_names.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/ptr_to_ref.hpp" 1 3 4
># 40 "/usr/include/boost/mpl/aux_/ptr_to_ref.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>template< typename T > static T const& ptr_to_ref(T*);
>
>}}}
># 18 "/usr/include/boost/mpl/aux_/overload_names.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/operators.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/overload_names.hpp" 2 3 4
># 22 "/usr/include/boost/mpl/set/aux_/has_key_impl.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost { namespace mpl {
>
>template<>
>struct has_key_impl< aux::set_tag >
>{
> template< typename Set, typename T > struct apply
># 47 "/usr/include/boost/mpl/set/aux_/has_key_impl.hpp" 3 4
> : bool_<
> ( sizeof( Set::is_masked_( aux::ptr_to_ref(static_cast<Set*>(0)), static_cast<aux::type_wrapper<T>*>(0) )
>
>
> ) == sizeof(aux::no_tag) )
> >
> {
>
> };
>};
>
>}}
># 19 "/usr/include/boost/mpl/set/aux_/at_impl.hpp" 2 3 4
>
>
>
>
>namespace boost { namespace mpl {
>
>template<>
>struct at_impl< aux::set_tag >
>{
> template< typename Set, typename T > struct apply
> {
> typedef typename if_<
> has_key_impl<aux::set_tag>::apply<Set,T>
> , T
> , void_
> >::type type;
> };
>};
>
>}}
># 19 "/usr/include/boost/mpl/set/set0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/set/aux_/clear_impl.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/set/aux_/clear_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/set/aux_/set0.hpp" 1 3 4
># 28 "/usr/include/boost/mpl/set/aux_/set0.hpp" 3 4
>namespace boost { namespace mpl {
># 53 "/usr/include/boost/mpl/set/aux_/set0.hpp" 3 4
>template< typename Dummy = na > struct set0
>{
> typedef set0<> item_;
> typedef item_ type;
> typedef aux::set_tag tag;
> typedef void_ last_masked_;
> typedef void_ item_type_;
> typedef long_<0> size;
> typedef long_<1> order;
>
> static aux::no_tag order_by_key_(set0<> const&, void const volatile*);
> static aux::yes_tag is_masked_(set0<> const&, void const volatile*);
>};
>
>}}
># 20 "/usr/include/boost/mpl/set/aux_/clear_impl.hpp" 2 3 4
>
>
>namespace boost { namespace mpl {
>
>template<>
>struct clear_impl< aux::set_tag >
>{
> template< typename Set > struct apply
> {
> typedef set0<> type;
> };
>};
>
>}}
># 20 "/usr/include/boost/mpl/set/set0.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/set/aux_/size_impl.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/set/aux_/size_impl.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<>
>struct size_impl< aux::set_tag >
>{
> template< typename Set > struct apply
> : Set::size
> {
> };
>};
>
>}}
># 22 "/usr/include/boost/mpl/set/set0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/set/aux_/empty_impl.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/set/aux_/empty_impl.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<>
>struct empty_impl< aux::set_tag >
>{
> template< typename Set > struct apply
> : not_< typename Set::size >
> {
> };
>};
>
>}}
># 23 "/usr/include/boost/mpl/set/set0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/set/aux_/insert_impl.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/set/aux_/insert_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/insert_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/insert_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct insert_impl;
>template< typename Sequence, typename Pos_or_T, typename T > struct insert;
>
>}}
># 19 "/usr/include/boost/mpl/set/aux_/insert_impl.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/set/aux_/item.hpp" 1 3 4
># 26 "/usr/include/boost/mpl/set/aux_/item.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename T, typename Base >
>struct s_item
> : Base
>{
> typedef s_item<T,Base> item_;
> typedef void_ last_masked_;
> typedef T item_type_;
> typedef Base base;
>
> typedef typename next< typename Base::size >::type size;
> typedef typename next< typename Base::order >::type order;
>
>
>
>
> typedef char (&order_tag_)[order::value];
>
>
> static order_tag_ order_by_key_(s_item const&, aux::type_wrapper<T>*); using Base::order_by_key_;
> static aux::no_tag is_masked_(s_item const&, aux::type_wrapper<T>*); using Base::is_masked_;
>};
>
>
>template< typename T, typename Base >
>struct s_mask
> : Base
>{
> typedef s_mask<T,Base> item_;
> typedef T last_masked_;
> typedef void_ item_type_;
> typedef Base base;
> typedef typename prior< typename Base::size >::type size;
>
> static aux::yes_tag is_masked_(s_mask const&, aux::type_wrapper<T>*); using Base::is_masked_;
>};
>
>
>template< typename T, typename Base >
>struct s_unmask
> : Base
>{
> typedef s_unmask<T,Base> item_;
> typedef void_ last_masked_;
> typedef T item_type_;
> typedef Base base;
> typedef typename next< typename Base::size >::type size;
>
> static aux::no_tag is_masked_(s_unmask const&, aux::type_wrapper<T>*); using Base::is_masked_;
>};
>
>}}
># 21 "/usr/include/boost/mpl/set/aux_/insert_impl.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/base.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/base.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename T = na
> >
>struct base
>{
> typedef typename T::base type;
> 
>};
>
>template<> struct base< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : base< T1 > { }; }; template< typename Tag > struct lambda< base< na > , Tag , int_<-1> > { typedef false_ is_le; typedef base< na > result_; typedef base< na > type; }; namespace aux { template< typename T1 > struct template_arity< base< T1 > > : int_<1> { }; template<> struct template_arity< base< na > > : int_<-1> { }; }
>
>}}
># 24 "/usr/include/boost/mpl/set/aux_/insert_impl.hpp" 2 3 4
>
>
>
>
>
>namespace boost { namespace mpl {
>
>namespace aux {
>template< typename Set, typename T > struct set_insert_impl
> : eval_if<
> has_key_impl<aux::set_tag>::apply<Set,T>
> , identity<Set>
> , eval_if<
> is_same< T,typename Set::last_masked_ >
> , base<Set>
> , identity< s_item<T,typename Set::item_> >
> >
> >
>{
>};
>}
>
>template<>
>struct insert_impl< aux::set_tag >
>{
> template<
> typename Set
> , typename PosOrKey
> , typename KeyOrNA
> >
> struct apply
> : aux::set_insert_impl<
> Set
> , typename if_na<KeyOrNA,PosOrKey>::type
> >
> {
> };
>};
>
>}}
># 24 "/usr/include/boost/mpl/set/set0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/set/aux_/erase_impl.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/set/aux_/erase_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/erase_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/erase_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct erase_impl;
>template< typename Sequence, typename First, typename Last > struct erase;
>
>}}
># 19 "/usr/include/boost/mpl/set/aux_/erase_impl.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/set/aux_/erase_key_impl.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/set/aux_/erase_key_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/erase_key_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/erase_key_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct erase_key_impl;
>template< typename Sequence, typename Key > struct erase_key;
>
>}}
># 19 "/usr/include/boost/mpl/set/aux_/erase_key_impl.hpp" 2 3 4
># 28 "/usr/include/boost/mpl/set/aux_/erase_key_impl.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<>
>struct erase_key_impl< aux::set_tag >
>{
> template<
> typename Set
> , typename T
> >
> struct apply
> : eval_if<
> has_key_impl<aux::set_tag>::apply<Set,T>
> , eval_if<
> is_same< T,typename Set::item_type_ >
> , base<Set>
> , identity< s_mask<T,typename Set::item_> >
> >
> , identity<Set>
> >
> {
> };
>};
>
>}}
># 20 "/usr/include/boost/mpl/set/aux_/erase_impl.hpp" 2 3 4
>
>
>namespace boost { namespace mpl {
>
>template<>
>struct erase_impl< aux::set_tag >
>{
> template<
> typename Set
> , typename Pos
> , typename unused_
> >
> struct apply
> : erase_key_impl<aux::set_tag>
> ::apply<Set,typename Pos::type>
> {
> };
>};
>
>}}
># 25 "/usr/include/boost/mpl/set/set0.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/set/aux_/key_type_impl.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/set/aux_/key_type_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/key_type_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/key_type_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct key_type_impl;
>template< typename AssociativeSequence, typename T > struct key_type;
>
>}}
># 19 "/usr/include/boost/mpl/set/aux_/key_type_impl.hpp" 2 3 4
>
>
>namespace boost { namespace mpl {
>
>template<>
>struct key_type_impl< aux::set_tag >
>{
> template< typename Set, typename T > struct apply
> {
> typedef T type;
> };
>};
>
>}}
># 28 "/usr/include/boost/mpl/set/set0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/set/aux_/value_type_impl.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/set/aux_/value_type_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/value_type_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/value_type_fwd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct value_type_impl;
>template< typename AssociativeSequence, typename T > struct value_type;
>
>}}
># 19 "/usr/include/boost/mpl/set/aux_/value_type_impl.hpp" 2 3 4
>
>
>namespace boost { namespace mpl {
>
>template<>
>struct value_type_impl< aux::set_tag >
>{
> template< typename Set, typename T > struct apply
> {
> typedef T type;
> };
>};
>
>}}
># 29 "/usr/include/boost/mpl/set/set0.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/set/aux_/begin_end_impl.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/set/aux_/begin_end_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/set/aux_/iterator.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/set/aux_/iterator.hpp" 3 4
># 1 "/usr/include/boost/mpl/has_key.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/has_key.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/has_key_impl.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/aux_/has_key_impl.hpp" 3 4
>namespace boost { namespace mpl {
>
>
>
>template< typename Tag > struct has_key_impl
>{
> template< typename AssociativeSequence, typename Key > struct apply;
>};
>
> template<> struct has_key_impl<non_sequence_tag> {};
>
>}}
># 21 "/usr/include/boost/mpl/has_key.hpp" 2 3 4
>
>
>
>namespace boost { namespace mpl {
>
>template<
> typename AssociativeSequence = na
> , typename Key = na
> >
>struct has_key
> : has_key_impl< typename sequence_tag<AssociativeSequence>::type >
> ::template apply<AssociativeSequence,Key>
>{
> 
>};
>
>template<> struct has_key< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : has_key< T1 , T2 > { }; }; template< typename Tag > struct lambda< has_key< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef has_key< na , na > result_; typedef has_key< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< has_key< T1 , T2 > > : int_<2> { }; template<> struct template_arity< has_key< na , na > > : int_<-1> { }; }
>
>}}
># 20 "/usr/include/boost/mpl/set/aux_/iterator.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost { namespace mpl {
>
>
>template< typename Set, typename Tail > struct s_iter;
>
>template< typename Set, typename Tail > struct s_iter_get
> : eval_if<
> has_key< Set,typename Tail::item_type_ >
> , identity< s_iter<Set,Tail> >
> , next< s_iter<Set,Tail> >
> >
>{
>};
>
>template< typename Set, typename Tail > struct s_iter_impl
>{
> typedef Tail tail_;
> typedef forward_iterator_tag category;
> typedef typename Tail::item_type_ type;
>
>
>
>
>};
>
>
>
>template< typename Set, typename Tail >
>struct next< s_iter<Set,Tail> >
> : s_iter_get< Set,typename Tail::base >
>{
>};
>
>template< typename Set >
>struct next< s_iter<Set,set0<> > >
>{
> typedef s_iter<Set,set0<> > type;
>};
>
>template< typename Set, typename Tail > struct s_iter
> : s_iter_impl<Set,Tail>
>{
>};
>
>template< typename Set > struct s_iter<Set, set0<> >
>{
> typedef forward_iterator_tag category;
>};
># 96 "/usr/include/boost/mpl/set/aux_/iterator.hpp" 3 4
>}}
># 20 "/usr/include/boost/mpl/set/aux_/begin_end_impl.hpp" 2 3 4
>
>namespace boost { namespace mpl {
>
>template<>
>struct begin_impl< aux::set_tag >
>{
> template< typename Set > struct apply
> : s_iter_get<Set,typename Set::item_>
> {
> };
>};
>
>template<>
>struct end_impl< aux::set_tag >
>{
> template< typename Set > struct apply
> {
> typedef s_iter< Set,set0<> > type;
> };
>};
>
>}}
># 30 "/usr/include/boost/mpl/set/set0.hpp" 2 3 4
># 19 "/usr/include/boost/multi_index/detail/no_duplicate_tags.hpp" 2 3 4
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
># 36 "/usr/include/boost/multi_index/detail/no_duplicate_tags.hpp" 3 4
>struct duplicate_tag_mark{};
>
>struct duplicate_tag_marker
>{
> template <typename MplSet,typename Tag>
> struct apply
> {
> typedef mpl::s_item<
> typename mpl::if_<mpl::has_key<MplSet,Tag>,duplicate_tag_mark,Tag>::type,
> MplSet
> > type;
> };
>};
>
>template<typename TagList>
>struct no_duplicate_tags
>{
> typedef typename mpl::fold<
> TagList,
> mpl::set0<>,
> duplicate_tag_marker
> >::type aux;
>
> static const bool value=!(mpl::has_key<aux,duplicate_tag_mark>::value)
> ;
>};
>
>
>
>
>
>struct duplicate_tag_list_marker
>{
> template <typename MplSet,typename Index>
> struct apply:mpl::fold<
> typename Index::tag_list,
> MplSet,
> duplicate_tag_marker>
> {
> };
>};
>
>template<typename IndexList>
>struct no_duplicate_tags_in_index_list
>{
> typedef typename mpl::fold<
> IndexList,
> mpl::set0<>,
> duplicate_tag_list_marker
> >::type aux;
>
> static const bool value=!(mpl::has_key<aux,duplicate_tag_mark>::value)
> ;
>};
>
>}
>
>}
>
>}
># 18 "/usr/include/boost/multi_index/tag.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/transform.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/transform.hpp" 3 4
># 1 "/usr/include/boost/mpl/reverse_fold.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/reverse_fold.hpp" 3 4
># 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/reverse_fold.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/reverse_fold_impl.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/aux_/reverse_fold_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/aux_/reverse_fold_impl.hpp" 2 3 4
># 35 "/usr/include/boost/mpl/aux_/reverse_fold_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>
>
>template<
> long N
> , typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_fold_impl;
>
>template<
> typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp >
>{
> typedef First iter0;
> typedef State fwd_state0;
> typedef fwd_state0 bkwd_state0;
> typedef bkwd_state0 state;
> typedef iter0 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp >
>{
> typedef First iter0;
> typedef State fwd_state0;
> typedef typename apply2< ForwardOp, fwd_state0, typename deref<iter0>::type >::type fwd_state1;
> typedef typename mpl::next<iter0>::type iter1;
>
>
> typedef fwd_state1 bkwd_state1;
> typedef typename apply2< BackwardOp, bkwd_state1, typename deref<iter0>::type >::type bkwd_state0;
> typedef bkwd_state0 state;
> typedef iter1 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp >
>{
> typedef First iter0;
> typedef State fwd_state0;
> typedef typename apply2< ForwardOp, fwd_state0, typename deref<iter0>::type >::type fwd_state1;
> typedef typename mpl::next<iter0>::type iter1;
> typedef typename apply2< ForwardOp, fwd_state1, typename deref<iter1>::type >::type fwd_state2;
> typedef typename mpl::next<iter1>::type iter2;
>
>
> typedef fwd_state2 bkwd_state2;
> typedef typename apply2< BackwardOp, bkwd_state2, typename deref<iter1>::type >::type bkwd_state1;
> typedef typename apply2< BackwardOp, bkwd_state1, typename deref<iter0>::type >::type bkwd_state0;
>
>
> typedef bkwd_state0 state;
> typedef iter2 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp >
>{
> typedef First iter0;
> typedef State fwd_state0;
> typedef typename apply2< ForwardOp, fwd_state0, typename deref<iter0>::type >::type fwd_state1;
> typedef typename mpl::next<iter0>::type iter1;
> typedef typename apply2< ForwardOp, fwd_state1, typename deref<iter1>::type >::type fwd_state2;
> typedef typename mpl::next<iter1>::type iter2;
> typedef typename apply2< ForwardOp, fwd_state2, typename deref<iter2>::type >::type fwd_state3;
> typedef typename mpl::next<iter2>::type iter3;
>
>
> typedef fwd_state3 bkwd_state3;
> typedef typename apply2< BackwardOp, bkwd_state3, typename deref<iter2>::type >::type bkwd_state2;
> typedef typename apply2< BackwardOp, bkwd_state2, typename deref<iter1>::type >::type bkwd_state1;
> typedef typename apply2< BackwardOp, bkwd_state1, typename deref<iter0>::type >::type bkwd_state0;
>
>
> typedef bkwd_state0 state;
> typedef iter3 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp >
>{
> typedef First iter0;
> typedef State fwd_state0;
> typedef typename apply2< ForwardOp, fwd_state0, typename deref<iter0>::type >::type fwd_state1;
> typedef typename mpl::next<iter0>::type iter1;
> typedef typename apply2< ForwardOp, fwd_state1, typename deref<iter1>::type >::type fwd_state2;
> typedef typename mpl::next<iter1>::type iter2;
> typedef typename apply2< ForwardOp, fwd_state2, typename deref<iter2>::type >::type fwd_state3;
> typedef typename mpl::next<iter2>::type iter3;
> typedef typename apply2< ForwardOp, fwd_state3, typename deref<iter3>::type >::type fwd_state4;
> typedef typename mpl::next<iter3>::type iter4;
>
>
> typedef fwd_state4 bkwd_state4;
> typedef typename apply2< BackwardOp, bkwd_state4, typename deref<iter3>::type >::type bkwd_state3;
> typedef typename apply2< BackwardOp, bkwd_state3, typename deref<iter2>::type >::type bkwd_state2;
> typedef typename apply2< BackwardOp, bkwd_state2, typename deref<iter1>::type >::type bkwd_state1;
> typedef typename apply2< BackwardOp, bkwd_state1, typename deref<iter0>::type >::type bkwd_state0;
>
>
> typedef bkwd_state0 state;
> typedef iter4 iterator;
>};
>
>template<
> long N
> , typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_fold_impl
>{
> typedef First iter0;
> typedef State fwd_state0;
> typedef typename apply2< ForwardOp, fwd_state0, typename deref<iter0>::type >::type fwd_state1;
> typedef typename mpl::next<iter0>::type iter1;
> typedef typename apply2< ForwardOp, fwd_state1, typename deref<iter1>::type >::type fwd_state2;
> typedef typename mpl::next<iter1>::type iter2;
> typedef typename apply2< ForwardOp, fwd_state2, typename deref<iter2>::type >::type fwd_state3;
> typedef typename mpl::next<iter2>::type iter3;
> typedef typename apply2< ForwardOp, fwd_state3, typename deref<iter3>::type >::type fwd_state4;
> typedef typename mpl::next<iter3>::type iter4;
>
>
> typedef reverse_fold_impl<
> ( (N - 4) < 0 ? 0 : N - 4 )
> , iter4
> , Last
> , fwd_state4
> , BackwardOp
> , ForwardOp
> > nested_chunk;
>
> typedef typename nested_chunk::state bkwd_state4;
> typedef typename apply2< BackwardOp, bkwd_state4, typename deref<iter3>::type >::type bkwd_state3;
> typedef typename apply2< BackwardOp, bkwd_state3, typename deref<iter2>::type >::type bkwd_state2;
> typedef typename apply2< BackwardOp, bkwd_state2, typename deref<iter1>::type >::type bkwd_state1;
> typedef typename apply2< BackwardOp, bkwd_state1, typename deref<iter0>::type >::type bkwd_state0;
>
>
> typedef bkwd_state0 state;
> typedef typename nested_chunk::iterator iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp >
>{
> typedef reverse_fold_impl<
> -1
> , typename mpl::next<First>::type
> , Last
> , typename apply2<ForwardOp,State, typename deref<First>::type>::type
> , BackwardOp
> , ForwardOp
> > nested_step;
>
> typedef typename apply2<
> BackwardOp
> , typename nested_step::state
> , typename deref<First>::type
> >::type state;
>
> typedef typename nested_step::iterator iterator;
>};
>
>template<
> typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp >
>{
> typedef State state;
> typedef Last iterator;
>};
>
>}}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 36 "/usr/include/boost/mpl/aux_/reverse_fold_impl.hpp" 2 3 4
># 22 "/usr/include/boost/mpl/reverse_fold.hpp" 2 3 4
>
>
>namespace boost { namespace mpl {
>
>template<
> typename Sequence = na
> , typename State = na
> , typename BackwardOp = na
> , typename ForwardOp = arg<1>
> >
>struct reverse_fold
>{
> typedef typename aux::reverse_fold_impl<
> ::boost::mpl::O1_size<Sequence>::value
> , typename begin<Sequence>::type
> , typename end<Sequence>::type
> , State
> , BackwardOp
> , ForwardOp
> >::state type;
>
> 
>};
>
>template<> struct reverse_fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : reverse_fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< reverse_fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_fold< na , na , na > result_; typedef reverse_fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< reverse_fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< reverse_fold< na , na , na > > : int_<-1> { }; }
>
>}}
># 20 "/usr/include/boost/mpl/transform.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/pair_view.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/pair_view.hpp" 3 4
># 1 "/usr/include/boost/mpl/iterator_category.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/iterator_category.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename Iterator = na
> >
>struct iterator_category
>{
> typedef typename Iterator::category type;
> 
>};
>
>template<> struct iterator_category< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : iterator_category< T1 > { }; }; template< typename Tag > struct lambda< iterator_category< na > , Tag , int_<-1> > { typedef false_ is_le; typedef iterator_category< na > result_; typedef iterator_category< na > type; }; namespace aux { template< typename T1 > struct template_arity< iterator_category< T1 > > : int_<1> { }; template<> struct template_arity< iterator_category< na > > : int_<-1> { }; }
>
>}}
># 20 "/usr/include/boost/mpl/pair_view.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/mpl/min_max.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/min_max.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename N1 = na
> , typename N2 = na
> >
>struct min
> : if_< less<N1,N2>,N1,N2 >
>{
>};
>
>template<
> typename N1 = na
> , typename N2 = na
> >
>struct max
> : if_< less<N1,N2>,N2,N1 >
>{
>};
>
>template<> struct min< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : min< T1 , T2 > { }; }; template< typename Tag > struct lambda< min< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef min< na , na > result_; typedef min< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< min< T1 , T2 > > : int_<2> { }; template<> struct template_arity< min< na , na > > : int_<-1> { }; }
>template<> struct max< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : max< T1 , T2 > { }; }; template< typename Tag > struct lambda< max< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef max< na , na > result_; typedef max< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< max< T1 , T2 > > : int_<2> { }; template<> struct template_arity< max< na , na > > : int_<-1> { }; }
>
>}}
># 25 "/usr/include/boost/mpl/pair_view.hpp" 2 3 4
>
>
>
>
>
>namespace boost { namespace mpl {
>
>namespace aux {
>struct pair_iter_tag;
># 59 "/usr/include/boost/mpl/pair_view.hpp" 3 4
>}
>
>template<
> typename Iter1
> , typename Iter2
> , typename Category
> >
>struct pair_iter
>{
> typedef aux::pair_iter_tag tag;
> typedef Category category;
> typedef Iter1 first;
> typedef Iter2 second;
># 85 "/usr/include/boost/mpl/pair_view.hpp" 3 4
>};
>
>
>
>
>template< typename Iter1, typename Iter2, typename C >
>struct deref< pair_iter<Iter1,Iter2,C> >
>{
> typedef pair<
> typename deref<Iter1>::type
> , typename deref<Iter2>::type
> > type;
>};
>
>template< typename Iter1, typename Iter2, typename C >
>struct next< pair_iter<Iter1,Iter2,C> >
>{
> typedef typename mpl::next<Iter1>::type i1_;
> typedef typename mpl::next<Iter2>::type i2_;
> typedef pair_iter<i1_,i2_,C> type;
>};
>
>template< typename Iter1, typename Iter2, typename C >
>struct prior< pair_iter<Iter1,Iter2,C> >
>{
> typedef typename mpl::prior<Iter1>::type i1_;
> typedef typename mpl::prior<Iter2>::type i2_;
> typedef pair_iter<i1_,i2_,C> type;
>};
>
>
>
>
>template<> struct advance_impl<aux::pair_iter_tag>
>{
> template< typename Iter, typename D > struct apply
> {
> typedef typename mpl::advance< typename Iter::first,D >::type i1_;
> typedef typename mpl::advance< typename Iter::second,D >::type i2_;
> typedef pair_iter<i1_,i2_,typename Iter::category> type;
> };
>};
>
>template<> struct distance_impl<aux::pair_iter_tag>
>{
> template< typename Iter1, typename Iter2 > struct apply
> {
>
> typedef typename mpl::distance<
> typename first<Iter1>::type
> , typename first<Iter2>::type
> >::type type;
> };
>};
>
>
>template<
> typename Sequence1 = na
> , typename Sequence2 = na
> >
>struct pair_view
>{
> typedef nested_begin_end_tag tag;
>
> typedef typename begin<Sequence1>::type iter1_;
> typedef typename begin<Sequence2>::type iter2_;
> typedef typename min<
> typename iterator_category<iter1_>::type
> , typename iterator_category<iter2_>::type
> >::type category_;
>
> typedef pair_iter<iter1_,iter2_,category_> begin;
>
> typedef pair_iter<
> typename end<Sequence1>::type
> , typename end<Sequence2>::type
> , category_
> > end;
>};
>
>template<> struct pair_view< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : pair_view< T1 , T2 > { }; }; template< typename Tag > struct lambda< pair_view< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef pair_view< na , na > result_; typedef pair_view< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< pair_view< T1 , T2 > > : int_<2> { }; template<> struct template_arity< pair_view< na , na > > : int_<-1> { }; }
>
>}}
># 21 "/usr/include/boost/mpl/transform.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/is_sequence.hpp" 1 3 4
># 40 "/usr/include/boost/mpl/is_sequence.hpp" 3 4
>namespace boost { namespace mpl {
># 90 "/usr/include/boost/mpl/is_sequence.hpp" 3 4
>template<
> typename T = na
> >
>struct is_sequence
> : not_< is_same< typename begin<T>::type, void_ > >
>{
> 
>};
># 108 "/usr/include/boost/mpl/is_sequence.hpp" 3 4
>template<> struct is_sequence< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_sequence< T1 > { }; }; template< typename Tag > struct lambda< is_sequence< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_sequence< na > result_; typedef is_sequence< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_sequence< T1 > > : int_<1> { }; template<> struct template_arity< is_sequence< na > > : int_<-1> { }; }
>
>}}
># 22 "/usr/include/boost/mpl/transform.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/bind.hpp" 1 3 4
># 25 "/usr/include/boost/mpl/transform.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/mpl/aux_/inserter_algorithm.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/inserter_algorithm.hpp" 3 4
># 1 "/usr/include/boost/mpl/back_inserter.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/back_inserter.hpp" 3 4
># 1 "/usr/include/boost/mpl/push_back.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/push_back.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/push_back_impl.hpp" 1 3 4
># 26 "/usr/include/boost/mpl/aux_/push_back_impl.hpp" 3 4
>namespace boost { namespace mpl {
>
>struct has_push_back_arg {};
>
>
>
>template< typename Tag >
>struct push_back_impl
>{
> template< typename Sequence, typename T > struct apply
> {
>
>
>
> struct REQUESTED_PUSH_BACK_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST; typedef struct REQUESTED_PUSH_BACK_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST44 : boost::mpl::assert_ { static boost::mpl::failed ************ (REQUESTED_PUSH_BACK_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST::************ assert_arg()) ( Sequence ) { return 0; } } mpl_assert_arg44; enum { mpl_assertion_in_line_44 = sizeof( boost::mpl::assertion_failed<(( boost::is_same< T, has_push_back_arg >::value ))>( mpl_assert_arg44::assert_arg() ) ) }
>
>
>
> ;
> };
>};
>
>template< typename Tag >
>struct has_push_back_impl
>{
> template< typename Seq > struct apply
>
> : aux::has_type< push_back< Seq, has_push_back_arg > >
> {
>
>
>
>
>
>
>
> };
>};
>
> template<> struct push_back_impl<non_sequence_tag> {};
> template<> struct has_push_back_impl<non_sequence_tag> {};
>
>}}
># 19 "/usr/include/boost/mpl/push_back.hpp" 2 3 4
>
>
>
>
>namespace boost { namespace mpl {
>
>template<
> typename Sequence = na
> , typename T = na
> >
>struct push_back
> : push_back_impl< typename sequence_tag<Sequence>::type >
> ::template apply< Sequence,T >
>{
> 
>};
>
>
>template<
> typename Sequence = na
> >
>struct has_push_back
> : has_push_back_impl< typename sequence_tag<Sequence>::type >
> ::template apply< Sequence >
>{
> 
>};
>
>
>template<> struct push_back< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : push_back< T1 , T2 > { }; }; template< typename Tag > struct lambda< push_back< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef push_back< na , na > result_; typedef push_back< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< push_back< T1 , T2 > > : int_<2> { }; template<> struct template_arity< push_back< na , na > > : int_<-1> { }; }
>template<> struct has_push_back< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : has_push_back< T1 > { }; }; template< typename Tag > struct lambda< has_push_back< na > , Tag , int_<-1> > { typedef false_ is_le; typedef has_push_back< na > result_; typedef has_push_back< na > type; }; namespace aux { template< typename T1 > struct template_arity< has_push_back< T1 > > : int_<1> { }; template<> struct template_arity< has_push_back< na > > : int_<-1> { }; }
>
>}}
># 19 "/usr/include/boost/mpl/back_inserter.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/inserter.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/inserter.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename Sequence
> , typename Operation
> >
>struct inserter
>{
> typedef Sequence state;
> typedef Operation operation;
>};
>
>}}
># 20 "/usr/include/boost/mpl/back_inserter.hpp" 2 3 4
>
>namespace boost {
>namespace mpl {
>
>template<
> typename Sequence
> >
>struct back_inserter
> : inserter< Sequence,push_back<> >
>{
>};
>
>}}
># 19 "/usr/include/boost/mpl/aux_/inserter_algorithm.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/front_inserter.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/front_inserter.hpp" 3 4
># 1 "/usr/include/boost/mpl/push_front.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/push_front.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/push_front_impl.hpp" 1 3 4
># 26 "/usr/include/boost/mpl/aux_/push_front_impl.hpp" 3 4
>namespace boost { namespace mpl {
>
>struct has_push_front_arg {};
>
>
>
>
>template< typename Tag >
>struct push_front_impl
>{
> template< typename Sequence, typename T > struct apply
> {
>
>
>
> struct REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST; typedef struct REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST45 : boost::mpl::assert_ { static boost::mpl::failed ************ (REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST::************ assert_arg()) ( Sequence ) { return 0; } } mpl_assert_arg45; enum { mpl_assertion_in_line_45 = sizeof( boost::mpl::assertion_failed<(( boost::is_same< T, has_push_front_arg >::value ))>( mpl_assert_arg45::assert_arg() ) ) }
>
>
>
> ;
> };
>};
>
>template< typename Tag >
>struct has_push_front_impl
>{
> template< typename Seq > struct apply
>
> : aux::has_type< push_front< Seq, has_push_front_arg > >
> {
>
>
>
>
>
>
>
> };
>};
>
> template<> struct push_front_impl<non_sequence_tag> {};
> template<> struct has_push_front_impl<non_sequence_tag> {};
>
>}}
># 19 "/usr/include/boost/mpl/push_front.hpp" 2 3 4
>
>
>
>
>namespace boost { namespace mpl {
>
>template<
> typename Sequence = na
> , typename T = na
> >
>struct push_front
> : push_front_impl< typename sequence_tag<Sequence>::type >
> ::template apply< Sequence,T >
>{
> 
>};
>
>
>template<
> typename Sequence = na
> >
>struct has_push_front
> : has_push_front_impl< typename sequence_tag<Sequence>::type >
> ::template apply< Sequence >
>{
> 
>};
>
>template<> struct push_front< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : push_front< T1 , T2 > { }; }; template< typename Tag > struct lambda< push_front< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef push_front< na , na > result_; typedef push_front< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< push_front< T1 , T2 > > : int_<2> { }; template<> struct template_arity< push_front< na , na > > : int_<-1> { }; }
>template<> struct has_push_front< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : has_push_front< T1 > { }; }; template< typename Tag > struct lambda< has_push_front< na > , Tag , int_<-1> > { typedef false_ is_le; typedef has_push_front< na > result_; typedef has_push_front< na > type; }; namespace aux { template< typename T1 > struct template_arity< has_push_front< T1 > > : int_<1> { }; template<> struct template_arity< has_push_front< na > > : int_<-1> { }; }
>
>}}
># 19 "/usr/include/boost/mpl/front_inserter.hpp" 2 3 4
>
>
>namespace boost { namespace mpl {
>
>template<
> typename Sequence
> >
>struct front_inserter
> : inserter< Sequence,push_front<> >
>{
>};
>
>}}
># 20 "/usr/include/boost/mpl/aux_/inserter_algorithm.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/mpl/clear.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/clear.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/clear_impl.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/aux_/clear_impl.hpp" 3 4
>namespace boost { namespace mpl {
>
>
>
>template< typename Tag >
>struct clear_impl
>{
> template< typename Sequence > struct apply;
>};
>
> template<> struct clear_impl<non_sequence_tag> {};
>
>}}
># 19 "/usr/include/boost/mpl/clear.hpp" 2 3 4
>
>
>
>
>namespace boost { namespace mpl {
>
>template<
> typename Sequence = na
> >
>struct clear
> : clear_impl< typename sequence_tag<Sequence>::type >
> ::template apply< Sequence >
>{
> 
>};
>
>template<> struct clear< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : clear< T1 > { }; }; template< typename Tag > struct lambda< clear< na > , Tag , int_<-1> > { typedef false_ is_le; typedef clear< na > result_; typedef clear< na > type; }; namespace aux { template< typename T1 > struct template_arity< clear< T1 > > : int_<1> { }; template<> struct template_arity< clear< na > > : int_<-1> { }; }
>
>}}
># 25 "/usr/include/boost/mpl/aux_/inserter_algorithm.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/preprocessor/default_params.hpp" 1 3 4
># 32 "/usr/include/boost/mpl/aux_/inserter_algorithm.hpp" 2 3 4
># 29 "/usr/include/boost/mpl/transform.hpp" 2 3 4
>
>namespace boost { namespace mpl {
>
>namespace aux {
>
>template<
> typename Seq
> , typename Op
> , typename In
> >
>struct transform1_impl
> : fold<
> Seq
> , typename In::state
> , bind2< typename lambda< typename In::operation >::type
> , _1
> , bind1< typename lambda<Op>::type, _2>
> >
> >
>{
>};
>
>template<
> typename Seq
> , typename Op
> , typename In
> >
>struct reverse_transform1_impl
> : reverse_fold<
> Seq
> , typename In::state
> , bind2< typename lambda< typename In::operation >::type
> , _1
> , bind1< typename lambda<Op>::type, _2>
> >
> >
>{
>};
>
>template<
> typename Seq1
> , typename Seq2
> , typename Op
> , typename In
> >
>struct transform2_impl
> : fold<
> pair_view<Seq1,Seq2>
> , typename In::state
> , bind2< typename lambda< typename In::operation >::type
> , _1
> , bind2<
> typename lambda<Op>::type
> , bind1<first<>,_2>
> , bind1<second<>,_2>
> >
> >
> >
>{
>};
>
>template<
> typename Seq1
> , typename Seq2
> , typename Op
> , typename In
> >
>struct reverse_transform2_impl
> : reverse_fold<
> pair_view<Seq1,Seq2>
> , typename In::state
> , bind2< typename lambda< typename In::operation >::type
> , _1
> , bind2< typename lambda< Op >::type
> , bind1<first<>,_2>
> , bind1<second<>,_2>
> >
> >
> >
>{
>};
>
>}
>
> template< typename P1 = na , typename P2 = na , typename P3 = na > struct transform1 : aux::transform1_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct transform1< P1 , P2,na > : if_< has_push_back< typename clear<P1>::type> , aux::transform1_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::reverse_transform1_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template< typename P1 = na , typename P2 = na , typename P3 = na > struct reverse_transform1 : aux::reverse_transform1_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct reverse_transform1< P1 , P2,na > : if_< has_push_back<P1> , aux::reverse_transform1_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::transform1_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template<> struct transform1< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : transform1< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< transform1< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef transform1< na , na , na > result_; typedef transform1< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< transform1< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< transform1< na , na , na > > : int_<-1> { }; } template<> struct reverse_transform1< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : reverse_transform1< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< reverse_transform1< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_transform1< na , na , na > result_; typedef reverse_transform1< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< reverse_transform1< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< reverse_transform1< na , na , na > > : int_<-1> { }; }
> template< typename P1 = na , typename P2 = na , typename P3 = na , typename P4 = na > struct transform2 : aux::transform2_impl< P1 , P2 , P3 , P4> { }; template< typename P1 , typename P2 , typename P3 > struct transform2< P1 , P2 , P3,na > : if_< has_push_back< typename clear<P1>::type> , aux::transform2_impl< P1 , P2 , P3 , back_inserter< typename clear<P1>::type > > , aux::reverse_transform2_impl< P1 , P2 , P3 , front_inserter< typename clear<P1>::type > > >::type { }; template< typename P1 = na , typename P2 = na , typename P3 = na , typename P4 = na > struct reverse_transform2 : aux::reverse_transform2_impl< P1 , P2 , P3 , P4> { }; template< typename P1 , typename P2 , typename P3 > struct reverse_transform2< P1 , P2 , P3,na > : if_< has_push_back<P1> , aux::reverse_transform2_impl< P1 , P2 , P3 , back_inserter< typename clear<P1>::type > > , aux::transform2_impl< P1 , P2 , P3 , front_inserter< typename clear<P1>::type > > >::type { }; template<> struct transform2< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : transform2< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< transform2< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef transform2< na , na , na , na > result_; typedef transform2< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< transform2< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< transform2< na , na , na , na > > : int_<-1> { }; } template<> struct reverse_transform2< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : reverse_transform2< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< reverse_transform2< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_transform2< na , na , na , na > result_; typedef reverse_transform2< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< reverse_transform2< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< reverse_transform2< na , na , na , na > > : int_<-1> { }; }
># 138 "/usr/include/boost/mpl/transform.hpp" 3 4
>template< typename Seq1 = na , typename Seq2OrOperation = na , typename OperationOrInserter = na , typename Inserter = na > struct transform { typedef typename eval_if< or_< is_na<OperationOrInserter> , is_lambda_expression< Seq2OrOperation > , not_< is_sequence<Seq2OrOperation> > > , transform1<Seq1,Seq2OrOperation,OperationOrInserter> , transform2<Seq1,Seq2OrOperation,OperationOrInserter,Inserter> >::type type; }; template<> struct transform< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : transform< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< transform< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef transform< na , na , na , na > result_; typedef transform< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< transform< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< transform< na , na , na , na > > : int_<-1> { }; }
>template< typename Seq1 = na , typename Seq2OrOperation = na , typename OperationOrInserter = na , typename Inserter = na > struct reverse_transform { typedef typename eval_if< or_< is_na<OperationOrInserter> , is_lambda_expression< Seq2OrOperation > , not_< is_sequence<Seq2OrOperation> > > , reverse_transform1<Seq1,Seq2OrOperation,OperationOrInserter> , reverse_transform2<Seq1,Seq2OrOperation,OperationOrInserter,Inserter> >::type type; }; template<> struct reverse_transform< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : reverse_transform< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< reverse_transform< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_transform< na , na , na , na > result_; typedef reverse_transform< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< reverse_transform< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< reverse_transform< na , na , na , na > > : int_<-1> { }; }
>
>
>
>}}
># 20 "/usr/include/boost/multi_index/tag.hpp" 2 3 4
>
># 1 "/usr/include/boost/preprocessor/facilities/intercept.hpp" 1 3 4
># 22 "/usr/include/boost/multi_index/tag.hpp" 2 3 4
># 50 "/usr/include/boost/multi_index/tag.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>struct tag_marker{};
>
>template<typename T>
>struct is_tag
>{
> static const bool value=(is_base_and_derived<tag_marker,T>::value);
>};
>
>}
>
>template<
> typename T0 =mpl::na , typename T1 =mpl::na , typename T2 =mpl::na , typename T3 =mpl::na , typename T4 =mpl::na , typename T5 =mpl::na , typename T6 =mpl::na , typename T7 =mpl::na , typename T8 =mpl::na , typename T9 =mpl::na , typename T10 =mpl::na , typename T11 =mpl::na , typename T12 =mpl::na , typename T13 =mpl::na , typename T14 =mpl::na , typename T15 =mpl::na , typename T16 =mpl::na , typename T17 =mpl::na , typename T18 =mpl::na , typename T19 =mpl::na
>
>
>
>>
>struct tag:private detail::tag_marker
>{
>
>
>
>
> typedef typename mpl::transform<
> mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19>,
> mpl::identity<mpl::_1>
> >::type type;
>
> static_assert(detail::no_duplicate_tags<type>::value, "detail::no_duplicate_tags<type>::value");
>};
>
>}
>
>}
># 22 "/usr/include/boost/multi_index/detail/ord_index_args.hpp" 2 3 4
>
>
>
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
># 43 "/usr/include/boost/multi_index/detail/ord_index_args.hpp" 3 4
>template<typename KeyFromValue>
>struct index_args_default_compare
>{
> typedef std::less<typename KeyFromValue::result_type> type;
>};
>
>template<typename Arg1,typename Arg2,typename Arg3>
>struct ordered_index_args
>{
> typedef is_tag<Arg1> full_form;
>
> typedef typename mpl::if_<
> full_form,
> Arg1,
> tag< > >::type tag_list_type;
> typedef typename mpl::if_<
> full_form,
> Arg2,
> Arg1>::type key_from_value_type;
> typedef typename mpl::if_<
> full_form,
> Arg3,
> Arg2>::type supplied_compare_type;
> typedef typename mpl::eval_if<
> mpl::is_na<supplied_compare_type>,
> index_args_default_compare<key_from_value_type>,
> mpl::identity<supplied_compare_type>
> >::type compare_type;
>
> static_assert(is_tag<tag_list_type>::value, "is_tag<tag_list_type>::value");
> static_assert(!mpl::is_na<key_from_value_type>::value, "!mpl::is_na<key_from_value_type>::value");
> static_assert(!mpl::is_na<compare_type>::value, "!mpl::is_na<compare_type>::value");
>};
>
>}
>
>}
>
>}
># 17 "/usr/include/boost/multi_index/ordered_index_fwd.hpp" 2 3 4
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>template<
> typename KeyFromValue,typename Compare,
> typename SuperMeta,typename TagList,typename Category
>>
>class ordered_index;
>
>template<
> typename KeyFromValue1,typename Compare1,
> typename SuperMeta1,typename TagList1,typename Category1,
> typename KeyFromValue2,typename Compare2,
> typename SuperMeta2,typename TagList2,typename Category2
>>
>bool operator==(
> const ordered_index<
> KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
> const ordered_index<
> KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y);
>
>template<
> typename KeyFromValue1,typename Compare1,
> typename SuperMeta1,typename TagList1,typename Category1,
> typename KeyFromValue2,typename Compare2,
> typename SuperMeta2,typename TagList2,typename Category2
>>
>bool operator<(
> const ordered_index<
> KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
> const ordered_index<
> KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y);
>
>template<
> typename KeyFromValue1,typename Compare1,
> typename SuperMeta1,typename TagList1,typename Category1,
> typename KeyFromValue2,typename Compare2,
> typename SuperMeta2,typename TagList2,typename Category2
>>
>bool operator!=(
> const ordered_index<
> KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
> const ordered_index<
> KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y);
>
>template<
> typename KeyFromValue1,typename Compare1,
> typename SuperMeta1,typename TagList1,typename Category1,
> typename KeyFromValue2,typename Compare2,
> typename SuperMeta2,typename TagList2,typename Category2
>>
>bool operator>(
> const ordered_index<
> KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
> const ordered_index<
> KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y);
>
>template<
> typename KeyFromValue1,typename Compare1,
> typename SuperMeta1,typename TagList1,typename Category1,
> typename KeyFromValue2,typename Compare2,
> typename SuperMeta2,typename TagList2,typename Category2
>>
>bool operator>=(
> const ordered_index<
> KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
> const ordered_index<
> KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y);
>
>template<
> typename KeyFromValue1,typename Compare1,
> typename SuperMeta1,typename TagList1,typename Category1,
> typename KeyFromValue2,typename Compare2,
> typename SuperMeta2,typename TagList2,typename Category2
>>
>bool operator<=(
> const ordered_index<
> KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
> const ordered_index<
> KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y);
>
>template<
> typename KeyFromValue,typename Compare,
> typename SuperMeta,typename TagList,typename Category
>>
>void swap(
> ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x,
> ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& y);
>
>}
>
>
>
>template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
>struct ordered_unique;
>
>template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
>struct ordered_non_unique;
>
>}
>
>}
># 20 "/usr/include/boost/multi_index_container_fwd.hpp" 2 3 4
>
>
>namespace boost{
>
>namespace multi_index{
>
>
>
>
>
>template<
> typename Value,
> typename IndexSpecifierList=indexed_by<ordered_unique<identity<Value> > >,
> typename Allocator=std::allocator<Value> >
>class multi_index_container;
>
>template<typename MultiIndexContainer,int N>
>struct nth_index;
>
>template<typename MultiIndexContainer,typename Tag>
>struct index;
>
>template<typename MultiIndexContainer,int N>
>struct nth_index_iterator;
>
>template<typename MultiIndexContainer,int N>
>struct nth_index_const_iterator;
>
>template<typename MultiIndexContainer,typename Tag>
>struct index_iterator;
>
>template<typename MultiIndexContainer,typename Tag>
>struct index_const_iterator;
>
>
>
>
>
>template<
> typename Value1,typename IndexSpecifierList1,typename Allocator1,
> typename Value2,typename IndexSpecifierList2,typename Allocator2
>>
>bool operator==(
> const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
> const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
>
>template<
> typename Value1,typename IndexSpecifierList1,typename Allocator1,
> typename Value2,typename IndexSpecifierList2,typename Allocator2
>>
>bool operator<(
> const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
> const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
>
>template<
> typename Value1,typename IndexSpecifierList1,typename Allocator1,
> typename Value2,typename IndexSpecifierList2,typename Allocator2
>>
>bool operator!=(
> const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
> const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
>
>template<
> typename Value1,typename IndexSpecifierList1,typename Allocator1,
> typename Value2,typename IndexSpecifierList2,typename Allocator2
>>
>bool operator>(
> const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
> const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
>
>template<
> typename Value1,typename IndexSpecifierList1,typename Allocator1,
> typename Value2,typename IndexSpecifierList2,typename Allocator2
>>
>bool operator>=(
> const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
> const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
>
>template<
> typename Value1,typename IndexSpecifierList1,typename Allocator1,
> typename Value2,typename IndexSpecifierList2,typename Allocator2
>>
>bool operator<=(
> const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
> const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
>
>template<typename Value,typename IndexSpecifierList,typename Allocator>
>void swap(
> multi_index_container<Value,IndexSpecifierList,Allocator>& x,
> multi_index_container<Value,IndexSpecifierList,Allocator>& y);
>
>}
>
>
>
>
>
>using multi_index::multi_index_container;
>
>}
># 31 "/usr/include/boost/multi_index_container.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/detail/access_specifier.hpp" 1 3 4
># 32 "/usr/include/boost/multi_index_container.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/detail/adl_swap.hpp" 1 3 4
># 19 "/usr/include/boost/multi_index/detail/adl_swap.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>template<typename T>
>void adl_swap(T& x,T& y)
>{
>
>
> using std::swap;
> swap(x,y);
>
>
>
>
>}
>
>}
>
>}
>
>}
># 33 "/usr/include/boost/multi_index_container.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/detail/base_type.hpp" 1 3 4
># 19 "/usr/include/boost/multi_index/detail/base_type.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
># 20 "/usr/include/boost/multi_index/detail/base_type.hpp" 2 3 4
>
># 1 "/usr/include/boost/multi_index/detail/index_base.hpp" 1 3 4
># 20 "/usr/include/boost/multi_index/detail/index_base.hpp" 3 4
># 1 "/usr/include/boost/multi_index/detail/copy_map.hpp" 1 3 4
># 19 "/usr/include/boost/multi_index/detail/copy_map.hpp" 3 4
># 1 "/usr/include/boost/multi_index/detail/auto_space.hpp" 1 3 4
># 20 "/usr/include/boost/multi_index/detail/auto_space.hpp" 3 4
># 1 "/usr/include/boost/multi_index/detail/prevent_eti.hpp" 1 3 4
># 25 "/usr/include/boost/multi_index/detail/prevent_eti.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
># 47 "/usr/include/boost/multi_index/detail/prevent_eti.hpp" 3 4
>template<typename Type,typename Construct>
>struct prevent_eti
>{
> typedef Construct type;
>};
>
>
>}
>
>}
>
>}
># 21 "/usr/include/boost/multi_index/detail/auto_space.hpp" 2 3 4
>
>
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
># 46 "/usr/include/boost/multi_index/detail/auto_space.hpp" 3 4
>template<typename T,typename Allocator=std::allocator<T> >
>struct auto_space:private noncopyable
>{
> typedef typename prevent_eti<
> Allocator,
> typename boost::detail::allocator::rebind_to<
> Allocator,T
> >::type
> >::type::pointer pointer;
>
> explicit auto_space(const Allocator& al=Allocator(),std::size_t n=1):
> al_(al),n_(n),data_(n_?al_.allocate(n_):pointer(0))
> {}
>
> ~auto_space()
> {
> if(n_)al_.deallocate(data_,n_);
> }
>
> Allocator get_allocator()const{return al_;}
>
> pointer data()const{return data_;}
>
> void swap(auto_space& x)
> {
> if(al_!=x.al_)adl_swap(al_,x.al_);
> std::swap(n_,x.n_);
> std::swap(data_,x.data_);
> }
>
>private:
> typename boost::detail::allocator::rebind_to<
> Allocator,T>::type al_;
> std::size_t n_;
> pointer data_;
>};
>
>template<typename T,typename Allocator>
>void swap(auto_space<T,Allocator>& x,auto_space<T,Allocator>& y)
>{
> x.swap(y);
>}
>
>}
>
>}
>
>}
># 20 "/usr/include/boost/multi_index/detail/copy_map.hpp" 2 3 4
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 23 "/usr/include/boost/multi_index/detail/copy_map.hpp" 2 3 4
>
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
># 43 "/usr/include/boost/multi_index/detail/copy_map.hpp" 3 4
>template <typename Node>
>struct copy_map_entry
>{
> copy_map_entry(Node* f,Node* s):first(f),second(s){}
>
> Node* first;
> Node* second;
>
> bool operator<(const copy_map_entry<Node>& x)const
> {
> return std::less<Node*>()(first,x.first);
> }
>};
>
>template <typename Node,typename Allocator>
>class copy_map:private noncopyable
>{
>public:
> typedef const copy_map_entry<Node>* const_iterator;
>
> copy_map(
> const Allocator& al,std::size_t size,Node* header_org,Node* header_cpy):
> al_(al),size_(size),spc(al_,size_),n(0),
> header_org_(header_org),header_cpy_(header_cpy),released(false)
> {}
>
> ~copy_map()
> {
> if(!released){
> for(std::size_t i=0;i<n;++i){
> boost::detail::allocator::destroy(&(spc.data()+i)->second->value());
> deallocate((spc.data()+i)->second);
> }
> }
> }
>
> const_iterator begin()const{return &*spc.data();}
> const_iterator end()const{return &*(spc.data()+n);}
>
> void clone(Node* node)
> {
> (spc.data()+n)->first=node;
> (spc.data()+n)->second=&*al_.allocate(1);
> { try{
> boost::detail::allocator::construct(
> &(spc.data()+n)->second->value(),node->value());
> }
> catch(...){
> deallocate((spc.data()+n)->second);
> throw;;
> }
> }
> ++n;
>
> if(n==size_)std::sort(&*spc.data(),&*spc.data()+size_);
> }
>
> Node* find(Node* node)const
> {
> if(node==header_org_)return header_cpy_;
> return std::lower_bound(
> begin(),end(),copy_map_entry<Node>(node,0))->second;
> }
>
> void release()
> {
> released=true;
> }
>
>private:
> typedef typename prevent_eti<
> Allocator,
> typename boost::detail::allocator::rebind_to<
> Allocator,Node>::type
> >::type allocator_type;
> typedef typename allocator_type::pointer allocator_pointer;
>
> allocator_type al_;
> std::size_t size_;
> auto_space<copy_map_entry<Node>,Allocator> spc;
> std::size_t n;
> Node* header_org_;
> Node* header_cpy_;
> bool released;
>
> void deallocate(Node* node)
> {
> al_.deallocate(static_cast<allocator_pointer>(node),1);
> }
>};
>
>}
>
>}
>
>}
># 21 "/usr/include/boost/multi_index/detail/index_base.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/detail/node_type.hpp" 1 3 4
># 18 "/usr/include/boost/multi_index/detail/node_type.hpp" 3 4
># 1 "/usr/include/boost/mpl/bind.hpp" 1 3 4
># 19 "/usr/include/boost/multi_index/detail/node_type.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/reverse_iter_fold.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/reverse_iter_fold.hpp" 3 4
># 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/reverse_iter_fold.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp" 2 3 4
># 34 "/usr/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>
>
>template<
> long N
> , typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_iter_fold_impl;
>
>template<
> typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_iter_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp >
>{
> typedef First iter0;
> typedef State fwd_state0;
> typedef fwd_state0 bkwd_state0;
> typedef bkwd_state0 state;
> typedef iter0 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_iter_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp >
>{
> typedef First iter0;
> typedef State fwd_state0;
> typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
> typedef typename mpl::next<iter0>::type iter1;
>
>
> typedef fwd_state1 bkwd_state1;
> typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
> typedef bkwd_state0 state;
> typedef iter1 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_iter_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp >
>{
> typedef First iter0;
> typedef State fwd_state0;
> typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
> typedef typename mpl::next<iter0>::type iter1;
> typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
> typedef typename mpl::next<iter1>::type iter2;
>
>
> typedef fwd_state2 bkwd_state2;
> typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
> typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
>
>
> typedef bkwd_state0 state;
> typedef iter2 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_iter_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp >
>{
> typedef First iter0;
> typedef State fwd_state0;
> typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
> typedef typename mpl::next<iter0>::type iter1;
> typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
> typedef typename mpl::next<iter1>::type iter2;
> typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;
> typedef typename mpl::next<iter2>::type iter3;
>
>
> typedef fwd_state3 bkwd_state3;
> typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;
> typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
> typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
>
>
> typedef bkwd_state0 state;
> typedef iter3 iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_iter_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp >
>{
> typedef First iter0;
> typedef State fwd_state0;
> typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
> typedef typename mpl::next<iter0>::type iter1;
> typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
> typedef typename mpl::next<iter1>::type iter2;
> typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;
> typedef typename mpl::next<iter2>::type iter3;
> typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4;
> typedef typename mpl::next<iter3>::type iter4;
>
>
> typedef fwd_state4 bkwd_state4;
> typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3;
> typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;
> typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
> typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
>
>
> typedef bkwd_state0 state;
> typedef iter4 iterator;
>};
>
>template<
> long N
> , typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_iter_fold_impl
>{
> typedef First iter0;
> typedef State fwd_state0;
> typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
> typedef typename mpl::next<iter0>::type iter1;
> typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
> typedef typename mpl::next<iter1>::type iter2;
> typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;
> typedef typename mpl::next<iter2>::type iter3;
> typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4;
> typedef typename mpl::next<iter3>::type iter4;
>
>
> typedef reverse_iter_fold_impl<
> ( (N - 4) < 0 ? 0 : N - 4 )
> , iter4
> , Last
> , fwd_state4
> , BackwardOp
> , ForwardOp
> > nested_chunk;
>
> typedef typename nested_chunk::state bkwd_state4;
> typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3;
> typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;
> typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
> typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
>
>
> typedef bkwd_state0 state;
> typedef typename nested_chunk::iterator iterator;
>};
>
>template<
> typename First
> , typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_iter_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp >
>{
> typedef reverse_iter_fold_impl<
> -1
> , typename mpl::next<First>::type
> , Last
> , typename apply2< ForwardOp,State,First >::type
> , BackwardOp
> , ForwardOp
> > nested_step;
>
> typedef typename apply2<
> BackwardOp
> , typename nested_step::state
> , First
> >::type state;
>
> typedef typename nested_step::iterator iterator;
>};
>
>template<
> typename Last
> , typename State
> , typename BackwardOp
> , typename ForwardOp
> >
>struct reverse_iter_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp >
>{
> typedef State state;
> typedef Last iterator;
>};
>
>}}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 35 "/usr/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp" 2 3 4
># 23 "/usr/include/boost/mpl/reverse_iter_fold.hpp" 2 3 4
>
>
>
>namespace boost { namespace mpl {
>
>template<
> typename Sequence = na
> , typename State = na
> , typename BackwardOp = na
> , typename ForwardOp = arg<1>
> >
>struct reverse_iter_fold
>{
> typedef typename aux::reverse_iter_fold_impl<
> ::boost::mpl::O1_size<Sequence>::value
> , typename begin<Sequence>::type
> , typename end<Sequence>::type
> , State
> , typename lambda<BackwardOp>::type
> , typename lambda<ForwardOp>::type
> >::state type;
>
> 
>
>
>
>
>};
>
>template<> struct reverse_iter_fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : reverse_iter_fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< reverse_iter_fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_iter_fold< na , na , na > result_; typedef reverse_iter_fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< reverse_iter_fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< reverse_iter_fold< na , na , na > > : int_<-1> { }; }
>
>}}
># 20 "/usr/include/boost/multi_index/detail/node_type.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/multi_index/detail/header_holder.hpp" 1 3 4
># 18 "/usr/include/boost/multi_index/detail/header_holder.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
># 32 "/usr/include/boost/multi_index/detail/header_holder.hpp" 3 4
>template<typename NodeTypePtr,typename Final>
>struct header_holder:private noncopyable
>{
> header_holder():member(final().allocate_node()){}
> ~header_holder(){final().deallocate_node(&*member);}
>
> NodeTypePtr member;
>
>private:
> Final& final(){return *static_cast<Final*>(this);}
>};
>
>}
>
>}
>
>}
># 23 "/usr/include/boost/multi_index/detail/node_type.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/detail/index_node_base.hpp" 1 3 4
># 21 "/usr/include/boost/multi_index/detail/index_node_base.hpp" 3 4
># 1 "/usr/include/boost/archive/archive_exception.hpp" 1 3 4
># 20 "/usr/include/boost/archive/archive_exception.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 21 "/usr/include/boost/archive/archive_exception.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/archive/detail/decl.hpp" 1 3 4
># 26 "/usr/include/boost/archive/archive_exception.hpp" 2 3 4
># 35 "/usr/include/boost/archive/archive_exception.hpp" 3 4
># 1 "/usr/include/boost/archive/detail/abi_prefix.hpp" 1 3 4
># 11 "/usr/include/boost/archive/detail/abi_prefix.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 12 "/usr/include/boost/archive/detail/abi_prefix.hpp" 2 3 4
># 36 "/usr/include/boost/archive/archive_exception.hpp" 2 3 4
>
>namespace boost {
>namespace archive {
>
>
>
>
>class archive_exception :
> public virtual std::exception
>{
>protected:
> char m_buffer[128];
>public:
> typedef enum {
> no_exception,
> other_exception,
> unregistered_class,
>
> invalid_signature,
>
> unsupported_version,
>
> pointer_conflict,
>
>
>
>
> incompatible_native_format,
>
> array_size_too_short,
> input_stream_error,
> invalid_class_name,
>
>
> unregistered_cast,
>
> unsupported_class_version,
>
>
> multiple_code_instantiation,
>
> output_stream_error
> } exception_code;
>public:
> exception_code code;
> archive_exception(
> exception_code c,
> const char * e1 = __null,
> const char * e2 = __null
> );
> virtual ~archive_exception() throw();
> virtual const char *what() const throw();
>protected:
> unsigned int
> append(unsigned int l, const char * a);
> archive_exception();
>};
>
>}
>}
>
># 1 "/usr/include/boost/archive/detail/abi_suffix.hpp" 1 3 4
># 14 "/usr/include/boost/archive/detail/abi_suffix.hpp" 3 4
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 15 "/usr/include/boost/archive/detail/abi_suffix.hpp" 2 3 4
># 98 "/usr/include/boost/archive/archive_exception.hpp" 2 3 4
># 22 "/usr/include/boost/multi_index/detail/index_node_base.hpp" 2 3 4
># 1 "/usr/include/boost/serialization/access.hpp" 1 3 4
># 21 "/usr/include/boost/serialization/access.hpp" 3 4
># 1 "/usr/include/boost/serialization/pfto.hpp" 1 3 4
># 43 "/usr/include/boost/serialization/pfto.hpp" 3 4
>namespace boost {
>namespace serialization {
>
>template<class T>
>struct pfto_wrapper {
> const T & t;
> operator const T & (){
> return t;
> }
> pfto_wrapper (const T & rhs) : t(rhs) {}
>};
>
>template<class T>
>pfto_wrapper< T > make_pfto_wrapper(const T & t, int){
> return pfto_wrapper< T >(t);
>}
>
>template<class T>
>pfto_wrapper< T > make_pfto_wrapper(const pfto_wrapper< T > & t, int){
> return t;
>}
>
>}
>}
># 22 "/usr/include/boost/serialization/access.hpp" 2 3 4
>
>namespace boost {
>
>namespace archive {
>namespace detail {
> template<class Archive, class T>
> class iserializer;
> template<class Archive, class T>
> class oserializer;
>}
>}
>
>namespace serialization {
>
>
>template<class Archive, class T>
>inline void serialize_adl(Archive &, T &, const unsigned int);
>namespace detail {
> template<class Archive, class T>
> struct member_saver;
> template<class Archive, class T>
> struct member_loader;
>}
>
>
>
>
>
>
>class access {
>public:
>
>
>
>
> template<class Archive, class T>
> friend struct detail::member_saver;
> template<class Archive, class T>
> friend struct detail::member_loader;
> template<class Archive, class T>
> friend class archive::detail::iserializer;
> template<class Archive, class T>
> friend class archive::detail::oserializer;
> template<class Archive, class T>
> friend inline void serialize(
> Archive & ar,
> T & t,
> const unsigned int file_version
> );
> template<class Archive, class T>
> friend inline void save_construct_data(
> Archive & ar,
> const T * t,
> const unsigned int file_version
> );
> template<class Archive, class T>
> friend inline void load_construct_data(
> Archive & ar,
> T * t,
> const unsigned int file_version
> );
>
>
>
> template<class Archive, class T>
> static void member_save(
> Archive & ar,
>
> T & t,
> const unsigned int file_version
> ){
> t.save(ar, file_version);
> }
> template<class Archive, class T>
> static void member_load(
> Archive & ar,
> T & t,
> const unsigned int file_version
> ){
> t.load(ar, file_version);
> }
> template<class Archive, class T>
> static void serialize(
> Archive & ar,
> T & t,
> const unsigned int file_version
> ){
># 118 "/usr/include/boost/serialization/access.hpp" 3 4
> t.serialize(ar, file_version);
> }
> template<class T>
> static void destroy( const T * t)
> {
>
>
> delete const_cast<T *>(t);
> }
> template<class T>
> static void construct(T * t){
>
>
>
> ::new(t)T;
> }
> template<class T, class U>
> static T & cast_reference(U & u){
> return static_cast<T &>(u);
> }
> template<class T, class U>
> static T * cast_pointer(U * u){
> return static_cast<T *>(u);
> }
>};
>
>}
>}
># 23 "/usr/include/boost/multi_index/detail/index_node_base.hpp" 2 3 4
>
>
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>
>
>
>
>template<typename Value>
>struct pod_value_holder
>{
> typename aligned_storage<
> sizeof(Value),
> alignment_of<Value>::value
> >::type space;
>};
>
>template<typename Value,typename Allocator>
>struct index_node_base:private pod_value_holder<Value>
>{
> typedef index_node_base base_type;
> typedef Value value_type;
> typedef Allocator allocator_type;
>
> value_type& value()
> {
> return *static_cast<value_type*>(
> static_cast<void*>(&this->space));
> }
>
> const value_type& value()const
> {
> return *static_cast<const value_type*>(
> static_cast<const void*>(&this->space));
> }
>
> static index_node_base* from_value(const value_type* p)
> {
> return static_cast<index_node_base *>(
> reinterpret_cast<pod_value_holder<Value>*>(
> const_cast<value_type*>(p)));
> }
>
>private:
>
> friend class boost::serialization::access;
>
>
>
>
>
>
> template<class Archive>
> void serialize(Archive&,const unsigned int)
> {
> }
>
>};
>
>template<typename Node,typename Value>
>Node* node_from_value(
> const Value* p
> )
>{
> typedef typename Node::allocator_type allocator_type;
> return static_cast<Node*>(
> index_node_base<Value,allocator_type>::from_value(p));
>}
>
>}
>
>}
># 111 "/usr/include/boost/multi_index/detail/index_node_base.hpp" 3 4
>namespace multi_index{
>namespace detail{
>
>
>template<class Archive,typename Value,typename Allocator>
>inline void load_construct_data(
> Archive&,boost::multi_index::detail::index_node_base<Value,Allocator>*,
> const unsigned int)
>{
> throw_exception(
> archive::archive_exception(archive::archive_exception::other_exception));
>}
>
>
>
>
>}
>}
>
>
>
>
>}
># 24 "/usr/include/boost/multi_index/detail/node_type.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/detail/is_index_list.hpp" 1 3 4
># 17 "/usr/include/boost/multi_index/detail/is_index_list.hpp" 3 4
># 1 "/usr/include/boost/mpl/empty.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/empty.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/empty_impl.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/aux_/empty_impl.hpp" 3 4
>namespace boost { namespace mpl {
>
>
>
>
>template< typename Tag >
>struct empty_impl
>{
> template< typename Sequence > struct apply
> : is_same<
> typename begin<Sequence>::type
> , typename end<Sequence>::type
> >
> {
> };
>};
>
> template<> struct empty_impl<non_sequence_tag> {};
>
>}}
># 20 "/usr/include/boost/mpl/empty.hpp" 2 3 4
>
>
>
>namespace boost { namespace mpl {
>
>template<
> typename Sequence = na
> >
>struct empty
> : empty_impl< typename sequence_tag<Sequence>::type >
> ::template apply< Sequence >
>{
> 
>};
>
>template<> struct empty< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : empty< T1 > { }; }; template< typename Tag > struct lambda< empty< na > , Tag , int_<-1> > { typedef false_ is_le; typedef empty< na > result_; typedef empty< na > type; }; namespace aux { template< typename T1 > struct template_arity< empty< T1 > > : int_<1> { }; template<> struct template_arity< empty< na > > : int_<-1> { }; }
>
>}}
># 18 "/usr/include/boost/multi_index/detail/is_index_list.hpp" 2 3 4
>
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>template<typename T>
>struct is_index_list
>{
> static const bool mpl_sequence=mpl::is_sequence<T>::value;
> static const bool non_empty=!mpl::empty<T>::value;
> static const bool value=mpl_sequence&&non_empty;
>};
>
>}
>
>}
>
>}
># 25 "/usr/include/boost/multi_index/detail/node_type.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/detail/msvc_index_specifier.hpp" 1 3 4
># 26 "/usr/include/boost/multi_index/detail/node_type.hpp" 2 3 4
>
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
># 49 "/usr/include/boost/multi_index/detail/node_type.hpp" 3 4
>struct index_node_applier
>{
> template<typename IndexSpecifierIterator,typename Super>
> struct apply
> {
> typedef typename mpl::deref<IndexSpecifierIterator>::type index_specifier;
> typedef typename index_specifier::
> template node_class<Super>::type type;
> };
>};
>
>
>template<typename Value,typename IndexSpecifierList,typename Allocator>
>struct multi_index_node_type
>{
> static_assert(detail::is_index_list<IndexSpecifierList>::value, "detail::is_index_list<IndexSpecifierList>::value");
>
> typedef typename mpl::reverse_iter_fold<
> IndexSpecifierList,
> index_node_base<Value,Allocator>,
> mpl::bind2<index_node_applier,mpl::_2,mpl::_1>
> >::type type;
>};
>
>}
>
>}
>
>}
># 22 "/usr/include/boost/multi_index/detail/index_base.hpp" 2 3 4
>
># 1 "/usr/include/boost/tuple/tuple.hpp" 1 3 4
># 32 "/usr/include/boost/tuple/tuple.hpp" 3 4
># 1 "/usr/include/boost/ref.hpp" 1 3 4
># 29 "/usr/include/boost/ref.hpp" 3 4
>namespace boost
>{
>
>template<class T> class reference_wrapper
>{
>public:
> typedef T type;
>
>
>
>
>
>
>
> explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
>
>
>
> operator T& () const { return *t_; }
>
> T& get() const { return *t_; }
>
> T* get_pointer() const { return t_; }
>
>private:
>
> T* t_;
>};
>
>
>
>
>
>
>
>template<class T> inline reference_wrapper<T> const ref(T & t)
>{
> return reference_wrapper<T>(t);
>}
>
>template<class T> inline reference_wrapper<T const> const cref(T const & t)
>{
> return reference_wrapper<T const>(t);
>}
>
>
>
>
>
>template<typename T>
>class is_reference_wrapper
> : public mpl::false_
>{
>};
>
>template<typename T>
>class unwrap_reference
>{
> public:
> typedef T type;
>};
># 106 "/usr/include/boost/ref.hpp" 3 4
>template<typename T> class is_reference_wrapper< reference_wrapper<T> > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> > { public: typedef T type; };
>
>template<typename T> class is_reference_wrapper< reference_wrapper<T> const > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> const > { public: typedef T type; };
>template<typename T> class is_reference_wrapper< reference_wrapper<T> volatile > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> volatile > { public: typedef T type; };
>template<typename T> class is_reference_wrapper< reference_wrapper<T> const volatile > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> const volatile > { public: typedef T type; };
># 176 "/usr/include/boost/ref.hpp" 3 4
>template <class T> inline typename unwrap_reference<T>::type&
>unwrap_ref(T& t)
>{
> return t;
>}
>
>template<class T> inline T* get_pointer( reference_wrapper<T> const & r )
>{
> return r.get_pointer();
>}
>
>}
># 33 "/usr/include/boost/tuple/tuple.hpp" 2 3 4
># 1 "/usr/include/boost/tuple/detail/tuple_basic.hpp" 1 3 4
># 44 "/usr/include/boost/tuple/detail/tuple_basic.hpp" 3 4
>namespace boost {
>namespace tuples {
>
>
>struct null_type {};
>
>
>namespace detail {
> inline const null_type cnull() { return null_type(); }
>
>
>
>
>
>template <bool If, class Then, class Else> struct IF { typedef Then RET; };
>
>template <class Then, class Else> struct IF<false, Then, Else> {
> typedef Else RET;
>};
>
>}
>
>
>template <class HT, class TT> struct cons;
>
>
>
>template <
> class T0 = null_type, class T1 = null_type, class T2 = null_type,
> class T3 = null_type, class T4 = null_type, class T5 = null_type,
> class T6 = null_type, class T7 = null_type, class T8 = null_type,
> class T9 = null_type>
>class tuple;
>
>
>template<class T> struct length;
>
>
>
>namespace detail {
>
>
>
>template<class T>
>class generate_error;
>
>template<int N>
>struct drop_front {
> template<class Tuple>
> struct apply {
> typedef typename drop_front<N-1>::template
> apply<Tuple> next;
> typedef typename next::type::tail_type type;
> static const type& call(const Tuple& tup) {
> return next::call(tup).tail;
> }
> };
>};
>
>template<>
>struct drop_front<0> {
> template<class Tuple>
> struct apply {
> typedef Tuple type;
> static const type& call(const Tuple& tup) {
> return tup;
> }
> };
>};
>
>}
># 124 "/usr/include/boost/tuple/detail/tuple_basic.hpp" 3 4
>template<int N, class T>
>struct element
>{
> typedef typename detail::drop_front<N>::template
> apply<T>::type::head_type type;
>};
>
>template<int N, class T>
>struct element<N, const T>
>{
>private:
> typedef typename detail::drop_front<N>::template
> apply<T>::type::head_type unqualified_type;
>public:
>
>
>
> typedef typename boost::add_const<unqualified_type>::type type;
>
>};
># 184 "/usr/include/boost/tuple/detail/tuple_basic.hpp" 3 4
>template <class T> struct access_traits {
> typedef const T& const_type;
> typedef T& non_const_type;
>
> typedef const typename boost::remove_cv<T>::type& parameter_type;
>
>
>
>
>
>
>};
>
>template <class T> struct access_traits<T&> {
>
> typedef T& const_type;
> typedef T& non_const_type;
>
> typedef T& parameter_type;
>};
>
>
>
>template<int N, class HT, class TT>
>inline typename access_traits<
> typename element<N, cons<HT, TT> >::type
> >::non_const_type
>get(cons<HT, TT>& c ) {
> typedef typename detail::drop_front<N>::template
> apply<cons<HT, TT> > impl;
> typedef typename impl::type cons_element;
> return const_cast<cons_element&>(impl::call(c)).head;
>}
>
>
>
>
>template<int N, class HT, class TT>
>inline typename access_traits<
> typename element<N, cons<HT, TT> >::type
> >::const_type
>get(const cons<HT, TT>& c ) {
> typedef typename detail::drop_front<N>::template
> apply<cons<HT, TT> > impl;
> return impl::call(c).head;
>}
>
>
>namespace detail {
>
>
>
>
>
>
>
>template <class T> class non_storeable_type {
> non_storeable_type();
>};
>
>template <class T> struct wrap_non_storeable_type {
> typedef typename IF<
> ::boost::is_function<T>::value, non_storeable_type<T>, T
> >::RET type;
>};
>template <> struct wrap_non_storeable_type<void> {
> typedef non_storeable_type<void> type;
>};
>
>}
>
>template <class HT, class TT>
>struct cons {
>
> typedef HT head_type;
> typedef TT tail_type;
>
> typedef typename
> detail::wrap_non_storeable_type<head_type>::type stored_head_type;
>
> stored_head_type head;
> tail_type tail;
>
> typename access_traits<stored_head_type>::non_const_type
> get_head() { return head; }
>
> typename access_traits<tail_type>::non_const_type
> get_tail() { return tail; }
>
> typename access_traits<stored_head_type>::const_type
> get_head() const { return head; }
>
> typename access_traits<tail_type>::const_type
> get_tail() const { return tail; }
>
> cons() : head(), tail() {}
>
>
>
>
>
>
>
> cons(typename access_traits<stored_head_type>::parameter_type h,
> const tail_type& t)
> : head (h), tail(t) {}
>
> template <class T1, class T2, class T3, class T4, class T5,
> class T6, class T7, class T8, class T9, class T10>
> cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,
> T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
> : head (t1),
> tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
> {}
>
> template <class T2, class T3, class T4, class T5,
> class T6, class T7, class T8, class T9, class T10>
> cons( const null_type& , T2& t2, T3& t3, T4& t4, T5& t5,
> T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
> : head (),
> tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
> {}
>
>
> template <class HT2, class TT2>
> cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}
>
> template <class HT2, class TT2>
> cons& operator=( const cons<HT2, TT2>& u ) {
> head=u.head; tail=u.tail; return *this;
> }
>
>
>
> cons& operator=(const cons& u) {
> head = u.head; tail = u.tail; return *this;
> }
>
> template <class T1, class T2>
> cons& operator=( const std::pair<T1, T2>& u ) {
> static_assert(length<cons>::value == 2, "length<cons>::value == 2");
> head = u.first; tail.head = u.second; return *this;
> }
>
>
> template <int N>
> typename access_traits<
> typename element<N, cons<HT, TT> >::type
> >::non_const_type
> get() {
> return boost::tuples::get<N>(*this);
> }
>
> template <int N>
> typename access_traits<
> typename element<N, cons<HT, TT> >::type
> >::const_type
> get() const {
> return boost::tuples::get<N>(*this);
> }
>};
>
>template <class HT>
>struct cons<HT, null_type> {
>
> typedef HT head_type;
> typedef null_type tail_type;
> typedef cons<HT, null_type> self_type;
>
> typedef typename
> detail::wrap_non_storeable_type<head_type>::type stored_head_type;
> stored_head_type head;
>
> typename access_traits<stored_head_type>::non_const_type
> get_head() { return head; }
>
> null_type get_tail() { return null_type(); }
>
> typename access_traits<stored_head_type>::const_type
> get_head() const { return head; }
>
> const null_type get_tail() const { return null_type(); }
>
>
> cons() : head() {}
>
> cons(typename access_traits<stored_head_type>::parameter_type h,
> const null_type& = null_type())
> : head (h) {}
>
> template<class T1>
> cons(T1& t1, const null_type&, const null_type&, const null_type&,
> const null_type&, const null_type&, const null_type&,
> const null_type&, const null_type&, const null_type&)
> : head (t1) {}
>
> cons(const null_type&,
> const null_type&, const null_type&, const null_type&,
> const null_type&, const null_type&, const null_type&,
> const null_type&, const null_type&, const null_type&)
> : head () {}
>
> template <class HT2>
> cons( const cons<HT2, null_type>& u ) : head(u.head) {}
>
> template <class HT2>
> cons& operator=(const cons<HT2, null_type>& u )
> { head = u.head; return *this; }
>
>
>
> cons& operator=(const cons& u) { head = u.head; return *this; }
>
> template <int N>
> typename access_traits<
> typename element<N, self_type>::type
> >::non_const_type
> get() {
> return boost::tuples::get<N>(*this);
> }
>
> template <int N>
> typename access_traits<
> typename element<N, self_type>::type
> >::const_type
> get() const {
> return boost::tuples::get<N>(*this);
> }
>
>};
>
>
>
>template<class T>
>struct length {
> static const int value = 1 + length<typename T::tail_type>::value;
>};
>
>template<>
>struct length<tuple<> > {
> static const int value = 0;
>};
>
>template<>
>struct length<tuple<> const> {
> static const int value = 0;
>};
>
>template<>
>struct length<null_type> {
> static const int value = 0;
>};
>
>template<>
>struct length<null_type const> {
> static const int value = 0;
>};
>
>namespace detail {
>
>
>template <class T0, class T1, class T2, class T3, class T4,
> class T5, class T6, class T7, class T8, class T9>
>struct map_tuple_to_cons
>{
> typedef cons<T0,
> typename map_tuple_to_cons<T1, T2, T3, T4, T5,
> T6, T7, T8, T9, null_type>::type
> > type;
>};
>
>
>template <>
>struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>
>{
> typedef null_type type;
>};
>
>}
>
>
>
>template <class T0, class T1, class T2, class T3, class T4,
> class T5, class T6, class T7, class T8, class T9>
>
>class tuple :
> public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
>{
>public:
> typedef typename
> detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
> typedef typename inherited::head_type head_type;
> typedef typename inherited::tail_type tail_type;
>
>
>
> tuple() {}
>
> tuple(typename access_traits<T0>::parameter_type t0)
> : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
> detail::cnull(), detail::cnull(), detail::cnull(),
> detail::cnull(), detail::cnull(), detail::cnull()) {}
>
> tuple(typename access_traits<T0>::parameter_type t0,
> typename access_traits<T1>::parameter_type t1)
> : inherited(t0, t1, detail::cnull(), detail::cnull(),
> detail::cnull(), detail::cnull(), detail::cnull(),
> detail::cnull(), detail::cnull(), detail::cnull()) {}
>
> tuple(typename access_traits<T0>::parameter_type t0,
> typename access_traits<T1>::parameter_type t1,
> typename access_traits<T2>::parameter_type t2)
> : inherited(t0, t1, t2, detail::cnull(), detail::cnull(),
> detail::cnull(), detail::cnull(), detail::cnull(),
> detail::cnull(), detail::cnull()) {}
>
> tuple(typename access_traits<T0>::parameter_type t0,
> typename access_traits<T1>::parameter_type t1,
> typename access_traits<T2>::parameter_type t2,
> typename access_traits<T3>::parameter_type t3)
> : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(),
> detail::cnull(), detail::cnull(), detail::cnull(),
> detail::cnull()) {}
>
> tuple(typename access_traits<T0>::parameter_type t0,
> typename access_traits<T1>::parameter_type t1,
> typename access_traits<T2>::parameter_type t2,
> typename access_traits<T3>::parameter_type t3,
> typename access_traits<T4>::parameter_type t4)
> : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(),
> detail::cnull(), detail::cnull(), detail::cnull()) {}
>
> tuple(typename access_traits<T0>::parameter_type t0,
> typename access_traits<T1>::parameter_type t1,
> typename access_traits<T2>::parameter_type t2,
> typename access_traits<T3>::parameter_type t3,
> typename access_traits<T4>::parameter_type t4,
> typename access_traits<T5>::parameter_type t5)
> : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(),
> detail::cnull(), detail::cnull()) {}
>
> tuple(typename access_traits<T0>::parameter_type t0,
> typename access_traits<T1>::parameter_type t1,
> typename access_traits<T2>::parameter_type t2,
> typename access_traits<T3>::parameter_type t3,
> typename access_traits<T4>::parameter_type t4,
> typename access_traits<T5>::parameter_type t5,
> typename access_traits<T6>::parameter_type t6)
> : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(),
> detail::cnull(), detail::cnull()) {}
>
> tuple(typename access_traits<T0>::parameter_type t0,
> typename access_traits<T1>::parameter_type t1,
> typename access_traits<T2>::parameter_type t2,
> typename access_traits<T3>::parameter_type t3,
> typename access_traits<T4>::parameter_type t4,
> typename access_traits<T5>::parameter_type t5,
> typename access_traits<T6>::parameter_type t6,
> typename access_traits<T7>::parameter_type t7)
> : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(),
> detail::cnull()) {}
>
> tuple(typename access_traits<T0>::parameter_type t0,
> typename access_traits<T1>::parameter_type t1,
> typename access_traits<T2>::parameter_type t2,
> typename access_traits<T3>::parameter_type t3,
> typename access_traits<T4>::parameter_type t4,
> typename access_traits<T5>::parameter_type t5,
> typename access_traits<T6>::parameter_type t6,
> typename access_traits<T7>::parameter_type t7,
> typename access_traits<T8>::parameter_type t8)
> : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {}
>
> tuple(typename access_traits<T0>::parameter_type t0,
> typename access_traits<T1>::parameter_type t1,
> typename access_traits<T2>::parameter_type t2,
> typename access_traits<T3>::parameter_type t3,
> typename access_traits<T4>::parameter_type t4,
> typename access_traits<T5>::parameter_type t5,
> typename access_traits<T6>::parameter_type t6,
> typename access_traits<T7>::parameter_type t7,
> typename access_traits<T8>::parameter_type t8,
> typename access_traits<T9>::parameter_type t9)
> : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}
>
>
> template<class U1, class U2>
> tuple(const cons<U1, U2>& p) : inherited(p) {}
>
> template <class U1, class U2>
> tuple& operator=(const cons<U1, U2>& k) {
> inherited::operator=(k);
> return *this;
> }
>
> template <class U1, class U2>
> tuple& operator=(const std::pair<U1, U2>& k) {
> static_assert(length<tuple>::value == 2, "length<tuple>::value == 2");
> this->head = k.first;
> this->tail.head = k.second;
> return *this;
> }
>
>};
>
>
>template <>
>class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type> :
> public null_type
>{
>public:
> typedef null_type inherited;
>};
>
>
>
>namespace detail {
>
>struct swallow_assign;
>typedef void (detail::swallow_assign::*ignore_t)();
>struct swallow_assign {
> swallow_assign(ignore_t(*)(ignore_t)) {}
> template<typename T>
> swallow_assign const& operator=(const T&) const {
> return *this;
> }
>};
>
>
>}
>
>
>inline detail::ignore_t ignore(detail::ignore_t) { return 0; }
># 635 "/usr/include/boost/tuple/detail/tuple_basic.hpp" 3 4
>template<class T>
>struct make_tuple_traits {
> typedef T type;
>
>
>
>
>
>
>
>};
># 659 "/usr/include/boost/tuple/detail/tuple_basic.hpp" 3 4
>template<class T>
>struct make_tuple_traits<T&> {
> typedef typename
> detail::generate_error<T&>::
> do_not_use_with_reference_type error;
>};
>
>
>
>
>
>template<class T, int n> struct make_tuple_traits <T[n]> {
> typedef const T (&type)[n];
>};
>
>template<class T, int n>
>struct make_tuple_traits<const T[n]> {
> typedef const T (&type)[n];
>};
>
>template<class T, int n> struct make_tuple_traits<volatile T[n]> {
> typedef const volatile T (&type)[n];
>};
>
>template<class T, int n>
>struct make_tuple_traits<const volatile T[n]> {
> typedef const volatile T (&type)[n];
>};
>
>template<class T>
>struct make_tuple_traits<reference_wrapper<T> >{
> typedef T& type;
>};
>
>template<class T>
>struct make_tuple_traits<const reference_wrapper<T> >{
> typedef T& type;
>};
>
>template<>
>struct make_tuple_traits<detail::ignore_t(detail::ignore_t)> {
> typedef detail::swallow_assign type;
>};
>
>
>
>namespace detail {
>
>
>
>template <
> class T0 = null_type, class T1 = null_type, class T2 = null_type,
> class T3 = null_type, class T4 = null_type, class T5 = null_type,
> class T6 = null_type, class T7 = null_type, class T8 = null_type,
> class T9 = null_type
>>
>struct make_tuple_mapper {
> typedef
> tuple<typename make_tuple_traits<T0>::type,
> typename make_tuple_traits<T1>::type,
> typename make_tuple_traits<T2>::type,
> typename make_tuple_traits<T3>::type,
> typename make_tuple_traits<T4>::type,
> typename make_tuple_traits<T5>::type,
> typename make_tuple_traits<T6>::type,
> typename make_tuple_traits<T7>::type,
> typename make_tuple_traits<T8>::type,
> typename make_tuple_traits<T9>::type> type;
>};
>
>}
>
>
>inline tuple<> make_tuple() {
> return tuple<>();
>}
>
>template<class T0>
>inline typename detail::make_tuple_mapper<T0>::type
>make_tuple(const T0& t0) {
> typedef typename detail::make_tuple_mapper<T0>::type t;
> return t(t0);
>}
>
>template<class T0, class T1>
>inline typename detail::make_tuple_mapper<T0, T1>::type
>make_tuple(const T0& t0, const T1& t1) {
> typedef typename detail::make_tuple_mapper<T0, T1>::type t;
> return t(t0, t1);
>}
>
>template<class T0, class T1, class T2>
>inline typename detail::make_tuple_mapper<T0, T1, T2>::type
>make_tuple(const T0& t0, const T1& t1, const T2& t2) {
> typedef typename detail::make_tuple_mapper<T0, T1, T2>::type t;
> return t(t0, t1, t2);
>}
>
>template<class T0, class T1, class T2, class T3>
>inline typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
>make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
> typedef typename detail::make_tuple_mapper<T0, T1, T2, T3>::type t;
> return t(t0, t1, t2, t3);
>}
>
>template<class T0, class T1, class T2, class T3, class T4>
>inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
>make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
> const T4& t4) {
> typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;
> return t(t0, t1, t2, t3, t4);
>}
>
>template<class T0, class T1, class T2, class T3, class T4, class T5>
>inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
>make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
> const T4& t4, const T5& t5) {
> typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;
> return t(t0, t1, t2, t3, t4, t5);
>}
>
>template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
>inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
>make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
> const T4& t4, const T5& t5, const T6& t6) {
> typedef typename detail::make_tuple_mapper
> <T0, T1, T2, T3, T4, T5, T6>::type t;
> return t(t0, t1, t2, t3, t4, t5, t6);
>}
>
>template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
> class T7>
>inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
>make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
> const T4& t4, const T5& t5, const T6& t6, const T7& t7) {
> typedef typename detail::make_tuple_mapper
> <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
> return t(t0, t1, t2, t3, t4, t5, t6, t7);
>}
>
>template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
> class T7, class T8>
>inline typename detail::make_tuple_mapper
> <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
>make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
> const T4& t4, const T5& t5, const T6& t6, const T7& t7,
> const T8& t8) {
> typedef typename detail::make_tuple_mapper
> <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
> return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
>}
>
>template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
> class T7, class T8, class T9>
>inline typename detail::make_tuple_mapper
> <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
>make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
> const T4& t4, const T5& t5, const T6& t6, const T7& t7,
> const T8& t8, const T9& t9) {
> typedef typename detail::make_tuple_mapper
> <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
> return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
>}
>
>namespace detail {
>
>template<class T>
>struct tie_traits {
> typedef T& type;
>};
>
>template<>
>struct tie_traits<ignore_t(ignore_t)> {
> typedef swallow_assign type;
>};
>
>template<>
>struct tie_traits<void> {
> typedef null_type type;
>};
>
>template <
> class T0 = void, class T1 = void, class T2 = void,
> class T3 = void, class T4 = void, class T5 = void,
> class T6 = void, class T7 = void, class T8 = void,
> class T9 = void
>>
>struct tie_mapper {
> typedef
> tuple<typename tie_traits<T0>::type,
> typename tie_traits<T1>::type,
> typename tie_traits<T2>::type,
> typename tie_traits<T3>::type,
> typename tie_traits<T4>::type,
> typename tie_traits<T5>::type,
> typename tie_traits<T6>::type,
> typename tie_traits<T7>::type,
> typename tie_traits<T8>::type,
> typename tie_traits<T9>::type> type;
>};
>
>}
>
>
>template<class T0>
>inline typename detail::tie_mapper<T0>::type
>tie(T0& t0) {
> typedef typename detail::tie_mapper<T0>::type t;
> return t(t0);
>}
>
>template<class T0, class T1>
>inline typename detail::tie_mapper<T0, T1>::type
>tie(T0& t0, T1& t1) {
> typedef typename detail::tie_mapper<T0, T1>::type t;
> return t(t0, t1);
>}
>
>template<class T0, class T1, class T2>
>inline typename detail::tie_mapper<T0, T1, T2>::type
>tie(T0& t0, T1& t1, T2& t2) {
> typedef typename detail::tie_mapper<T0, T1, T2>::type t;
> return t(t0, t1, t2);
>}
>
>template<class T0, class T1, class T2, class T3>
>inline typename detail::tie_mapper<T0, T1, T2, T3>::type
>tie(T0& t0, T1& t1, T2& t2, T3& t3) {
> typedef typename detail::tie_mapper<T0, T1, T2, T3>::type t;
> return t(t0, t1, t2, t3);
>}
>
>template<class T0, class T1, class T2, class T3, class T4>
>inline typename detail::tie_mapper<T0, T1, T2, T3, T4>::type
>tie(T0& t0, T1& t1, T2& t2, T3& t3,
> T4& t4) {
> typedef typename detail::tie_mapper<T0, T1, T2, T3, T4>::type t;
> return t(t0, t1, t2, t3, t4);
>}
>
>template<class T0, class T1, class T2, class T3, class T4, class T5>
>inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5>::type
>tie(T0& t0, T1& t1, T2& t2, T3& t3,
> T4& t4, T5& t5) {
> typedef typename detail::tie_mapper<T0, T1, T2, T3, T4, T5>::type t;
> return t(t0, t1, t2, t3, t4, t5);
>}
>
>template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
>inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5, T6>::type
>tie(T0& t0, T1& t1, T2& t2, T3& t3,
> T4& t4, T5& t5, T6& t6) {
> typedef typename detail::tie_mapper
> <T0, T1, T2, T3, T4, T5, T6>::type t;
> return t(t0, t1, t2, t3, t4, t5, t6);
>}
>
>template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
> class T7>
>inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
>tie(T0& t0, T1& t1, T2& t2, T3& t3,
> T4& t4, T5& t5, T6& t6, T7& t7) {
> typedef typename detail::tie_mapper
> <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
> return t(t0, t1, t2, t3, t4, t5, t6, t7);
>}
>
>template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
> class T7, class T8>
>inline typename detail::tie_mapper
> <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
>tie(T0& t0, T1& t1, T2& t2, T3& t3,
> T4& t4, T5& t5, T6& t6, T7& t7,
> T8& t8) {
> typedef typename detail::tie_mapper
> <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
> return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
>}
>
>template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
> class T7, class T8, class T9>
>inline typename detail::tie_mapper
> <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
>tie(T0& t0, T1& t1, T2& t2, T3& t3,
> T4& t4, T5& t5, T6& t6, T7& t7,
> T8& t8, T9& t9) {
> typedef typename detail::tie_mapper
> <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
> return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
>}
>
>template <class T0, class T1, class T2, class T3, class T4,
> class T5, class T6, class T7, class T8, class T9>
>void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
> tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs);
>inline void swap(null_type&, null_type&) {}
>template<class HH>
>inline void swap(cons<HH, null_type>& lhs, cons<HH, null_type>& rhs) {
> ::boost::swap(lhs.head, rhs.head);
>}
>template<class HH, class TT>
>inline void swap(cons<HH, TT>& lhs, cons<HH, TT>& rhs) {
> ::boost::swap(lhs.head, rhs.head);
> ::boost::tuples::swap(lhs.tail, rhs.tail);
>}
>template <class T0, class T1, class T2, class T3, class T4,
> class T5, class T6, class T7, class T8, class T9>
>inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
> tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs) {
> typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tuple_type;
> typedef typename tuple_type::inherited base;
> ::boost::tuples::swap(static_cast<base&>(lhs), static_cast<base&>(rhs));
>}
>
>}
>}
># 34 "/usr/include/boost/tuple/tuple.hpp" 2 3 4
>
>
>
>namespace boost {
>
>using tuples::tuple;
>using tuples::make_tuple;
>using tuples::tie;
>
>using tuples::get;
># 87 "/usr/include/boost/tuple/tuple.hpp" 3 4
>}
># 24 "/usr/include/boost/multi_index/detail/index_base.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/multi_index/detail/index_loader.hpp" 1 3 4
># 21 "/usr/include/boost/multi_index/detail/index_loader.hpp" 3 4
># 1 "/usr/include/boost/serialization/nvp.hpp" 1 3 4
># 31 "/usr/include/boost/serialization/nvp.hpp" 3 4
># 1 "/usr/include/boost/serialization/level.hpp" 1 3 4
># 34 "/usr/include/boost/serialization/level.hpp" 3 4
># 1 "/usr/include/boost/serialization/level_enum.hpp" 1 3 4
># 19 "/usr/include/boost/serialization/level_enum.hpp" 3 4
>namespace boost {
>namespace serialization {
>
>
>
>
>
>enum level_type
>{
>
>
> not_serializable = 0,
>
>
>
>
>
>
> primitive_type = 1,
>
>
>
> object_serializable = 2,
>
>
>
>
>
>
>
> object_class_info = 3
>};
>
>}
>}
># 35 "/usr/include/boost/serialization/level.hpp" 2 3 4
>
>namespace boost {
>namespace serialization {
>
>struct basic_traits;
>
>
>template<class T>
>struct implementation_level_impl {
> template<class U>
> struct traits_class_level {
> typedef typename U::level type;
> };
>
> typedef mpl::integral_c_tag tag;
>
>
> typedef
> typename mpl::eval_if<
> is_base_and_derived<boost::serialization::basic_traits, T>,
> traits_class_level< T >,
>
> typename mpl::eval_if<
> is_fundamental< T >,
> mpl::int_<primitive_type>,
>
> typename mpl::eval_if<
> is_class< T >,
> mpl::int_<object_class_info>,
>
> typename mpl::eval_if<
> is_array< T >,
>
>
>
> mpl::int_<object_serializable>,
>
>
> typename mpl::eval_if<
> is_enum< T >,
>
>
>
> mpl::int_<primitive_type>,
>
>
> mpl::int_<not_serializable>
> >
> >
> >
> >
> >::type type;
>
> static const int value = type::value;
>};
>
>template<class T>
>struct implementation_level :
> public implementation_level_impl<const T>
>{
>};
>
>template<class T, int L >
>inline bool operator>=(implementation_level< T > t, enum level_type l)
>{
> return t.value >= (int)l;
>}
>
>}
>}
># 32 "/usr/include/boost/serialization/nvp.hpp" 2 3 4
># 1 "/usr/include/boost/serialization/tracking.hpp" 1 3 4
># 24 "/usr/include/boost/serialization/tracking.hpp" 3 4
># 1 "/usr/include/boost/mpl/equal_to.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/equal_to.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
># 27 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
># 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename Tag1
> , typename Tag2
> >
>struct equal_to_impl
> : if_c<
> ( Tag1::value
> > Tag2::value
> )
>
> , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 >
> , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 >
> >::type
>{
>};
>
>
>template<> struct equal_to_impl< na,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct equal_to_impl< na,Tag >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct equal_to_impl< Tag,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename T > struct equal_to_tag
>{
> typedef typename T::tag type;
>};
>
>template<
> typename N1 = na
> , typename N2 = na
> >
>struct equal_to
>
> : equal_to_impl<
> typename equal_to_tag<N1>::type
> , typename equal_to_tag<N2>::type
> >::template apply< N1,N2 >::type
>{
> 
>
>};
>
>template<> struct equal_to< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : equal_to< T1 , T2 > { }; }; template< typename Tag > struct lambda< equal_to< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef equal_to< na , na > result_; typedef equal_to< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< equal_to< T1 , T2 > > : int_<2> { }; template<> struct template_arity< equal_to< na , na > > : int_<-1> { }; }
>
>}}
>
>namespace boost { namespace mpl {
>
>template<>
>struct equal_to_impl< integral_c_tag,integral_c_tag >
>{
> template< typename N1, typename N2 > struct apply
>
> : bool_< ( N1::value == N2::value ) >
> {
> };
>};
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
># 20 "/usr/include/boost/mpl/equal_to.hpp" 2 3 4
># 25 "/usr/include/boost/serialization/tracking.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/greater.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/greater.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
># 27 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
># 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/greater.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/greater.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename Tag1
> , typename Tag2
> >
>struct greater_impl
> : if_c<
> ( Tag1::value
> > Tag2::value
> )
>
> , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 >
> , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 >
> >::type
>{
>};
>
>
>template<> struct greater_impl< na,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct greater_impl< na,Tag >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct greater_impl< Tag,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename T > struct greater_tag
>{
> typedef typename T::tag type;
>};
>
>template<
> typename N1 = na
> , typename N2 = na
> >
>struct greater
>
> : greater_impl<
> typename greater_tag<N1>::type
> , typename greater_tag<N2>::type
> >::template apply< N1,N2 >::type
>{
> 
>
>};
>
>template<> struct greater< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : greater< T1 , T2 > { }; }; template< typename Tag > struct lambda< greater< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef greater< na , na > result_; typedef greater< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< greater< T1 , T2 > > : int_<2> { }; template<> struct template_arity< greater< na , na > > : int_<-1> { }; }
>
>}}
>
>namespace boost { namespace mpl {
>
>template<>
>struct greater_impl< integral_c_tag,integral_c_tag >
>{
> template< typename N1, typename N2 > struct apply
>
> : bool_< ( N1::value > N2::value ) >
> {
> };
>};
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
># 20 "/usr/include/boost/mpl/greater.hpp" 2 3 4
># 26 "/usr/include/boost/serialization/tracking.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/serialization/tracking_enum.hpp" 1 3 4
># 19 "/usr/include/boost/serialization/tracking_enum.hpp" 3 4
>namespace boost {
>namespace serialization {
>
>
>
>
>
>
>enum tracking_type
>{
>
> track_never = 0,
>
>
> track_selectively = 1,
>
> track_always = 2
>};
>
>}
>}
># 32 "/usr/include/boost/serialization/tracking.hpp" 2 3 4
># 1 "/usr/include/boost/serialization/type_info_implementation.hpp" 1 3 4
># 27 "/usr/include/boost/serialization/type_info_implementation.hpp" 3 4
># 1 "/usr/include/boost/serialization/traits.hpp" 1 3 4
># 35 "/usr/include/boost/serialization/traits.hpp" 3 4
>namespace boost {
>namespace serialization {
>
>
>struct basic_traits {};
>
>template <class T>
>struct extended_type_info_impl;
>
>template<
> class T,
> int Level,
> int Tracking,
> unsigned int Version = 0,
> class ETII = extended_type_info_impl< T >,
> class Wrapper = mpl::false_
>>
>struct traits : public basic_traits {
> static_assert(Version == 0 || Level >= object_class_info, "Version == 0 || Level >= object_class_info");
> static_assert(Tracking == track_never || Level >= object_serializable, "Tracking == track_never || Level >= object_serializable");
> typedef typename mpl::int_<Level> level;
> typedef typename mpl::int_<Tracking> tracking;
> typedef typename mpl::int_<Version> version;
> typedef ETII type_info_implementation;
> typedef Wrapper is_wrapper;
>};
>
>}
>}
># 28 "/usr/include/boost/serialization/type_info_implementation.hpp" 2 3 4
>
>namespace boost {
>namespace serialization {
>
>
>
>template<class T>
>struct type_info_implementation {
> template<class U>
> struct traits_class_typeinfo_implementation {
> typedef typename U::type_info_implementation::type type;
> };
>
>
> typedef
> typename mpl::eval_if<
> is_base_and_derived<boost::serialization::basic_traits, T>,
> traits_class_typeinfo_implementation< T >,
>
> mpl::identity<
> typename extended_type_info_impl< T >::type
> >
> >::type type;
>};
>
>}
>}
># 33 "/usr/include/boost/serialization/tracking.hpp" 2 3 4
>
>namespace boost {
>namespace serialization {
>
>struct basic_traits;
>
>
>template<class T>
>struct tracking_level_impl {
> template<class U>
> struct traits_class_tracking {
> typedef typename U::tracking type;
> };
> typedef mpl::integral_c_tag tag;
>
>
> typedef
> typename mpl::eval_if<
> is_base_and_derived<boost::serialization::basic_traits, T>,
> traits_class_tracking< T >,
>
> typename mpl::eval_if<
> is_pointer< T >,
>
> mpl::int_<track_never>,
>
> typename mpl::eval_if<
>
> typename mpl::equal_to<
> implementation_level< T >,
> mpl::int_<primitive_type>
> >,
>
> mpl::int_<track_never>,
>
> mpl::int_<track_selectively>
> > > >::type type;
> static const int value = type::value;
>};
>
>template<class T>
>struct tracking_level :
> public tracking_level_impl<const T>
>{
>};
>
>template<class T, enum tracking_type L>
>inline bool operator>=(tracking_level< T > t, enum tracking_type l)
>{
> return t.value >= (int)l;
>}
>
>}
>}
># 33 "/usr/include/boost/serialization/nvp.hpp" 2 3 4
># 1 "/usr/include/boost/serialization/split_member.hpp" 1 3 4
># 25 "/usr/include/boost/serialization/split_member.hpp" 3 4
>namespace boost {
>namespace archive {
> namespace detail {
> template<class Archive> class interface_oarchive;
> template<class Archive> class interface_iarchive;
> }
>}
>
>namespace serialization {
>namespace detail {
>
> template<class Archive, class T>
> struct member_saver {
> static void invoke(
> Archive & ar,
> const T & t,
> const unsigned int file_version
> ){
> access::member_save(ar, t, file_version);
> }
> };
>
> template<class Archive, class T>
> struct member_loader {
> static void invoke(
> Archive & ar,
> T & t,
> const unsigned int file_version
> ){
> access::member_load(ar, t, file_version);
> }
> };
>
>}
>
>template<class Archive, class T>
>inline void split_member(
> Archive & ar, T & t, const unsigned int file_version
>){
> typedef typename mpl::eval_if<
> typename Archive::is_saving,
> mpl::identity<detail::member_saver<Archive, T> >,
> mpl::identity<detail::member_loader<Archive, T> >
> >::type typex;
> typex::invoke(ar, t, file_version);
>}
>
>}
>}
># 34 "/usr/include/boost/serialization/nvp.hpp" 2 3 4
># 1 "/usr/include/boost/serialization/base_object.hpp" 1 3 4
># 38 "/usr/include/boost/serialization/base_object.hpp" 3 4
># 1 "/usr/include/boost/serialization/force_include.hpp" 1 3 4
># 39 "/usr/include/boost/serialization/base_object.hpp" 2 3 4
># 1 "/usr/include/boost/serialization/void_cast_fwd.hpp" 1 3 4
># 20 "/usr/include/boost/serialization/void_cast_fwd.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 21 "/usr/include/boost/serialization/void_cast_fwd.hpp" 2 3 4
>
>
>namespace boost {
>namespace serialization {
>namespace void_cast_detail{
>class void_caster;
>}
>template<class Derived, class Base>
>
>inline const void_cast_detail::void_caster & void_cast_register(
> const Derived * dnull = __null,
> const Base * bnull = __null
>) __attribute__ ((__used__));
>}
>}
># 40 "/usr/include/boost/serialization/base_object.hpp" 2 3 4
>
>namespace boost {
>namespace serialization {
>
>namespace detail
>{
>
>
> template<class B, class D>
> struct base_cast
> {
> typedef typename
> mpl::if_<
> is_const<D>,
> const B,
> B
> >::type type;
> static_assert(is_const<type>::value == is_const<D>::value, "is_const<type>::value == is_const<D>::value");
> };
>
>
> template<class Base, class Derived>
> struct base_register
> {
> struct polymorphic {
> static void const * invoke(){
> Base const * const b = 0;
> Derived const * const d = 0;
> return & void_cast_register(d, b);
> }
> };
> struct non_polymorphic {
> static void const * invoke(){
> return 0;
> }
> };
> static void const * invoke(){
> typedef typename mpl::eval_if<
> is_polymorphic<Base>,
> mpl::identity<polymorphic>,
> mpl::identity<non_polymorphic>
> >::type type;
> return type::invoke();
> }
> };
>
>}
># 97 "/usr/include/boost/serialization/base_object.hpp" 3 4
>template<class Base, class Derived>
>typename detail::base_cast<Base, Derived>::type &
>base_object(Derived &d)
>{
> static_assert(( is_base_and_derived<Base,Derived>::value), "( is_base_and_derived<Base,Derived>::value)");
> static_assert(! is_pointer<Derived>::value, "! is_pointer<Derived>::value");
> typedef typename detail::base_cast<Base, Derived>::type type;
> detail::base_register<type, Derived>::invoke();
> return access::cast_reference<type, Derived>(d);
>}
>
>
>}
>}
># 35 "/usr/include/boost/serialization/nvp.hpp" 2 3 4
>
># 1 "/usr/include/boost/serialization/wrapper.hpp" 1 3 4
># 14 "/usr/include/boost/serialization/wrapper.hpp" 3 4
>namespace boost { namespace serialization {
>
>
>
>
>
>
>
>template<
> class T,
> int Level = object_serializable,
> int Tracking = track_never,
> unsigned int Version = 0,
> class ETII = extended_type_info_impl< T >
>>
>struct wrapper_traits :
> public traits<T,Level,Tracking,Version,ETII,mpl::true_>
>{};
>
>template<class T>
>struct is_wrapper_impl :
> boost::mpl::eval_if<
> boost::is_base_and_derived<basic_traits,T>,
> boost::mpl::true_,
> boost::mpl::false_
> >::type
>{};
>
>template<class T>
>struct is_wrapper {
> typedef typename is_wrapper_impl<const T>::type type;
>};
>
>}
>}
># 37 "/usr/include/boost/serialization/nvp.hpp" 2 3 4
>
>namespace boost {
>namespace serialization {
>
>template<class T>
>struct nvp :
> public std::pair<const char *, T *>,
> public wrapper_traits<const nvp< T > >
>{
> explicit nvp(const char * name_, T & t) :
>
>
> std::pair<const char *, T *>(name_, (T*)(& t))
> {}
> nvp(const nvp & rhs) :
>
> std::pair<const char *, T *>(rhs.first, (T*)rhs.second)
> {}
>
> const char * name() const {
> return this->first;
> }
> T & value() const {
> return *(this->second);
> }
>
> const T & const_value() const {
> return *(this->second);
> }
>
>
>
>
>
>
>
> template<class Archivex>
> void save(
> Archivex & ar,
> const unsigned int
> ) const {
>
> ar.operator<<(const_value());
> }
> template<class Archivex>
> void load(
> Archivex & ar,
> const unsigned int
> ){
>
> ar.operator>>(value());
> }
> template<class Archive> void serialize( Archive &ar, const unsigned int file_version ){ boost::serialization::split_member(ar, *this, file_version); }
>};
>
>template<class T>
>inline
>
>const
>
>nvp< T > make_nvp(const char * name, T & t){
> return nvp< T >(name, t);
>}
># 128 "/usr/include/boost/serialization/nvp.hpp" 3 4
>}
>}
># 22 "/usr/include/boost/multi_index/detail/index_loader.hpp" 2 3 4
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 24 "/usr/include/boost/multi_index/detail/index_loader.hpp" 2 3 4
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>
>
>
>
>
>
>template<typename Node,typename FinalNode,typename Allocator>
>class index_loader:private noncopyable
>{
>public:
> index_loader(const Allocator& al,std::size_t size):
> spc(al,size),size_(size),n(0),sorted(false)
> {
> }
>
> template<class Archive>
> void add(Node* node,Archive& ar,const unsigned int)
> {
> ar>>serialization::make_nvp("position",*node);
> entries()[n++]=node;
> }
>
> template<class Archive>
> void add_track(Node* node,Archive& ar,const unsigned int)
> {
> ar>>serialization::make_nvp("position",*node);
> }
>
>
>
>
>
>
>
> template<typename Rearranger,class Archive>
> void load(Rearranger r,Archive& ar,const unsigned int)const
> {
> FinalNode* prev=unchecked_load_node(ar);
> if(!prev)return;
>
> if(!sorted){
> std::sort(entries(),entries()+size_);
> sorted=true;
> }
>
> check_node(prev);
>
> for(;;){
> for(;;){
> FinalNode* node=load_node(ar);
> if(!node)break;
>
> if(node==prev)prev=0;
> r(prev,node);
>
> prev=node;
> }
> prev=load_node(ar);
> if(!prev)break;
> }
> }
>
>private:
> Node** entries()const{return &*spc.data();}
>
>
>
>
>
> template<class Archive>
> FinalNode* unchecked_load_node(Archive& ar)const
> {
> Node* node=0;
> ar>>serialization::make_nvp("pointer",node);
> return static_cast<FinalNode*>(node);
> }
>
> template<class Archive>
> FinalNode* load_node(Archive& ar)const
> {
> Node* node=0;
> ar>>serialization::make_nvp("pointer",node);
> check_node(node);
> return static_cast<FinalNode*>(node);
> }
>
> void check_node(Node* node)const
> {
> if(node!=0&&!std::binary_search(entries(),entries()+size_,node)){
> throw_exception(
> archive::archive_exception(
> archive::archive_exception::other_exception));
> }
> }
>
> auto_space<Node*,Allocator> spc;
> std::size_t size_;
> std::size_t n;
> mutable bool sorted;
>};
>
>}
>
>}
>
>}
># 28 "/usr/include/boost/multi_index/detail/index_base.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/detail/index_saver.hpp" 1 3 4
># 17 "/usr/include/boost/multi_index/detail/index_saver.hpp" 3 4
># 1 "/usr/include/boost/multi_index/detail/index_matcher.hpp" 1 3 4
># 20 "/usr/include/boost/multi_index/detail/index_matcher.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 21 "/usr/include/boost/multi_index/detail/index_matcher.hpp" 2 3 4
>
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
># 58 "/usr/include/boost/multi_index/detail/index_matcher.hpp" 3 4
>namespace index_matcher{
># 67 "/usr/include/boost/multi_index/detail/index_matcher.hpp" 3 4
>struct entry
>{
> entry(void* node_,std::size_t pos_=0):node(node_),pos(pos_){}
>
>
>
> void* node;
> std::size_t pos;
> entry* previous;
> bool ordered;
>
> struct less_by_node
> {
> bool operator()(
> const entry& x,const entry& y)const
> {
> return std::less<void*>()(x.node,y.node);
> }
> };
>
>
>
> std::size_t pile_top;
> entry* pile_top_entry;
>
> struct less_by_pile_top
> {
> bool operator()(
> const entry& x,const entry& y)const
> {
> return x.pile_top<y.pile_top;
> }
> };
>};
>
>
>
>template<typename Allocator>
>class algorithm_base:private noncopyable
>{
>protected:
> algorithm_base(const Allocator& al,std::size_t size):
> spc(al,size),size_(size),n_(0),sorted(false)
> {
> }
>
> void add(void* node)
> {
> entries()[n_]=entry(node,n_);
> ++n_;
> }
>
> void begin_algorithm()const
> {
> if(!sorted){
> std::sort(entries(),entries()+size_,entry::less_by_node());
> sorted=true;
> }
> num_piles=0;
> }
>
> void add_node_to_algorithm(void* node)const
> {
> entry* ent=
> std::lower_bound(
> entries(),entries()+size_,
> entry(node),entry::less_by_node());
> ent->ordered=false;
> std::size_t n=ent->pos;
>
> entry dummy(0);
> dummy.pile_top=n;
>
> entry* pile_ent=
> std::lower_bound(
> entries(),entries()+num_piles,
> dummy,entry::less_by_pile_top());
>
> pile_ent->pile_top=n;
> pile_ent->pile_top_entry=ent;
>
>
> if(pile_ent>&entries()[0]){
> ent->previous=(pile_ent-1)->pile_top_entry;
> }
>
> if(pile_ent==&entries()[num_piles]){
> ++num_piles;
> }
> }
>
> void finish_algorithm()const
> {
> if(num_piles>0){
>
>
>
>
>
> entry* ent=entries()[num_piles-1].pile_top_entry;
> for(std::size_t n=num_piles;n--;){
> ent->ordered=true;
> ent=ent->previous;
> }
> }
> }
>
> bool is_ordered(void * node)const
> {
> return std::lower_bound(
> entries(),entries()+size_,
> entry(node),entry::less_by_node())->ordered;
> }
>
>private:
> entry* entries()const{return &*spc.data();}
>
> auto_space<entry,Allocator> spc;
> std::size_t size_;
> std::size_t n_;
> mutable bool sorted;
> mutable std::size_t num_piles;
>};
>
>
>
>
>
>
>
>template<typename Node,typename Allocator>
>class algorithm:private algorithm_base<Allocator>
>{
> typedef algorithm_base<Allocator> super;
>
>public:
> algorithm(const Allocator& al,std::size_t size):super(al,size){}
>
> void add(Node* node)
> {
> super::add(node);
> }
>
> template<typename IndexIterator>
> void execute(IndexIterator first,IndexIterator last)const
> {
> super::begin_algorithm();
>
> for(IndexIterator it=first;it!=last;++it){
> add_node_to_algorithm(get_node(it));
> }
>
> super::finish_algorithm();
> }
>
> bool is_ordered(Node* node)const
> {
> return super::is_ordered(node);
> }
>
>private:
> void add_node_to_algorithm(Node* node)const
> {
> super::add_node_to_algorithm(node);
> }
>
> template<typename IndexIterator>
> static Node* get_node(IndexIterator it)
> {
> return static_cast<Node*>(it.get_node());
> }
>};
>
>}
>
>}
>
>}
>
>}
># 18 "/usr/include/boost/multi_index/detail/index_saver.hpp" 2 3 4
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 21 "/usr/include/boost/multi_index/detail/index_saver.hpp" 2 3 4
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
># 37 "/usr/include/boost/multi_index/detail/index_saver.hpp" 3 4
>template<typename Node,typename Allocator>
>class index_saver:private noncopyable
>{
>public:
> index_saver(const Allocator& al,std::size_t size):alg(al,size){}
>
> template<class Archive>
> void add(Node* node,Archive& ar,const unsigned int)
> {
> ar<<serialization::make_nvp("position",*node);
> alg.add(node);
> }
>
> template<class Archive>
> void add_track(Node* node,Archive& ar,const unsigned int)
> {
> ar<<serialization::make_nvp("position",*node);
> }
>
> template<typename IndexIterator,class Archive>
> void save(
> IndexIterator first,IndexIterator last,Archive& ar,
> const unsigned int)const
> {
>
>
> alg.execute(first,last);
># 95 "/usr/include/boost/multi_index/detail/index_saver.hpp" 3 4
> std::size_t last_saved=3;
> for(IndexIterator it=first,prev=first;it!=last;prev=it++,++last_saved){
> if(!alg.is_ordered(get_node(it))){
> if(last_saved>1)save_node(get_node(prev),ar);
> save_node(get_node(it),ar);
> last_saved=0;
> }
> else if(last_saved==2)save_node(null_node(),ar);
> }
> if(last_saved<=2)save_node(null_node(),ar);
>
>
>
> save_node(null_node(),ar);
> }
>
>private:
> template<typename IndexIterator>
> static Node* get_node(IndexIterator it)
> {
> return it.get_node();
> }
>
> static Node* null_node(){return 0;}
>
> template<typename Archive>
> static void save_node(Node* node,Archive& ar)
> {
> ar<<serialization::make_nvp("pointer",node);
> }
>
> index_matcher::algorithm<Node,Allocator> alg;
>};
>
>}
>
>}
>
>}
># 29 "/usr/include/boost/multi_index/detail/index_base.hpp" 2 3 4
>
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
># 45 "/usr/include/boost/multi_index/detail/index_base.hpp" 3 4
>template<typename Value,typename IndexSpecifierList,typename Allocator>
>class index_base
>{
>protected:
> typedef index_node_base<Value,Allocator> node_type;
> typedef typename multi_index_node_type<
> Value,IndexSpecifierList,Allocator>::type final_node_type;
> typedef multi_index_container<
> Value,IndexSpecifierList,Allocator> final_type;
> typedef tuples::null_type ctor_args_list;
> typedef typename
> boost::detail::allocator::rebind_to<
> Allocator,
> typename Allocator::value_type>::type final_allocator_type;
> typedef mpl::vector0<> index_type_list;
> typedef mpl::vector0<> iterator_type_list;
> typedef mpl::vector0<> const_iterator_type_list;
> typedef copy_map<
> final_node_type,
> final_allocator_type> copy_map_type;
>
>
> typedef index_saver<
> node_type,
> final_allocator_type> index_saver_type;
> typedef index_loader<
> node_type,
> final_node_type,
> final_allocator_type> index_loader_type;
>
>
>private:
> typedef typename call_traits<Value>::param_type value_param_type;
>
>protected:
> explicit index_base(const ctor_args_list&,const Allocator&){}
>
> void copy_(
> const index_base<Value,IndexSpecifierList,Allocator>&,const copy_map_type&)
> {}
>
> node_type* insert_(value_param_type v,node_type* x)
> {
> boost::detail::allocator::construct(&x->value(),v);
> return x;
> }
>
> node_type* insert_(value_param_type v,node_type*,node_type* x)
> {
> boost::detail::allocator::construct(&x->value(),v);
> return x;
> }
>
> void erase_(node_type* x)
> {
> boost::detail::allocator::destroy(&x->value());
> }
>
> void delete_node_(node_type* x)
> {
> boost::detail::allocator::destroy(&x->value());
> }
>
> void clear_(){}
>
> void swap_(index_base<Value,IndexSpecifierList,Allocator>&){}
>
> bool replace_(value_param_type v,node_type* x)
> {
> x->value()=v;
> return true;
> }
>
> bool modify_(node_type*){return true;}
>
> bool modify_rollback_(node_type*){return true;}
>
>
>
>
> template<typename Archive>
> void save_(Archive&,const unsigned int,const index_saver_type&)const{}
>
> template<typename Archive>
> void load_(Archive&,const unsigned int,const index_loader_type&){}
># 140 "/usr/include/boost/multi_index/detail/index_base.hpp" 3 4
> final_type& final(){return *static_cast<final_type*>(this);}
> const final_type& final()const{return *static_cast<const final_type*>(this);}
>
> final_node_type* final_header()const{return final().header();}
>
> bool final_empty_()const{return final().empty_();}
> std::size_t final_size_()const{return final().size_();}
> std::size_t final_max_size_()const{return final().max_size_();}
>
> std::pair<final_node_type*,bool> final_insert_(value_param_type x)
> {return final().insert_(x);}
> std::pair<final_node_type*,bool> final_insert_(
> value_param_type x,final_node_type* position)
> {return final().insert_(x,position);}
>
> void final_erase_(final_node_type* x){final().erase_(x);}
>
> void final_delete_node_(final_node_type* x){final().delete_node_(x);}
> void final_delete_all_nodes_(){final().delete_all_nodes_();}
> void final_clear_(){final().clear_();}
>
> void final_swap_(final_type& x){final().swap_(x);}
> bool final_replace_(
> value_param_type k,final_node_type* x)
> {return final().replace_(k,x);}
>
> template<typename Modifier>
> bool final_modify_(Modifier& mod,final_node_type* x)
> {return final().modify_(mod,x);}
>
> template<typename Modifier,typename Rollback>
> bool final_modify_(Modifier& mod,Rollback& back,final_node_type* x)
> {return final().modify_(mod,back,x);}
>
>
>
>
>};
>
>}
>
>}
>
>}
># 22 "/usr/include/boost/multi_index/detail/base_type.hpp" 2 3 4
>
>
>
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
># 47 "/usr/include/boost/multi_index/detail/base_type.hpp" 3 4
>struct index_applier
>{
> template<typename IndexSpecifierMeta,typename SuperMeta>
> struct apply
> {
> typedef typename IndexSpecifierMeta::type index_specifier;
> typedef typename index_specifier::
> template index_class<SuperMeta>::type type;
> };
>};
>
>
>template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
>struct nth_layer
>{
> static const int length=mpl::size<IndexSpecifierList>::value;
>
> typedef typename mpl::eval_if_c<
> N==length,
> mpl::identity<index_base<Value,IndexSpecifierList,Allocator> >,
> mpl::apply2<
> index_applier,
> mpl::at_c<IndexSpecifierList,N>,
> nth_layer<N+1,Value,IndexSpecifierList,Allocator>
> >
> >::type type;
>};
>
>template<typename Value,typename IndexSpecifierList,typename Allocator>
>struct multi_index_base_type:nth_layer<0,Value,IndexSpecifierList,Allocator>
>{
> static_assert(detail::is_index_list<IndexSpecifierList>::value, "detail::is_index_list<IndexSpecifierList>::value");
>};
>
>}
>
>}
>
>}
># 34 "/usr/include/boost/multi_index_container.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/detail/converter.hpp" 1 3 4
># 16 "/usr/include/boost/multi_index/detail/converter.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>
>
>
>
>
>template<typename MultiIndexContainer,typename Index>
>struct converter
>{
> static const Index& index(const MultiIndexContainer& x){return x;}
> static Index& index(MultiIndexContainer& x){return x;}
>
> static typename Index::const_iterator const_iterator(
> const MultiIndexContainer& x,typename MultiIndexContainer::node_type* node)
> {
> return x.Index::make_iterator(node);
> }
>
> static typename Index::iterator iterator(
> MultiIndexContainer& x,typename MultiIndexContainer::node_type* node)
> {
> return x.Index::make_iterator(node);
> }
>};
>
>}
>
>}
>
>}
># 35 "/usr/include/boost/multi_index_container.hpp" 2 3 4
>
># 1 "/usr/include/boost/multi_index/detail/has_tag.hpp" 1 3 4
># 19 "/usr/include/boost/multi_index/detail/has_tag.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>
>
>template<typename Tag>
>struct has_tag
>{
> template<typename Index>
> struct apply:mpl::contains<typename Index::tag_list,Tag>
> {
> };
>};
>
>}
>
>}
>
>}
># 37 "/usr/include/boost/multi_index_container.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/multi_index/detail/safe_mode.hpp" 1 3 4
># 40 "/usr/include/boost/multi_index_container.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/detail/scope_guard.hpp" 1 3 4
># 18 "/usr/include/boost/multi_index/detail/scope_guard.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
># 59 "/usr/include/boost/multi_index/detail/scope_guard.hpp" 3 4
>class scope_guard_impl_base
>{
>public:
> scope_guard_impl_base():dismissed_(false){}
> void dismiss()const{dismissed_=true;}
>
>
>
>
> void touch()const{}
>
>protected:
> ~scope_guard_impl_base(){}
>
> scope_guard_impl_base(const scope_guard_impl_base& other):
> dismissed_(other.dismissed_)
> {
> other.dismiss();
> }
>
> template<typename J>
> static void safe_execute(J& j){
> { try{
> if(!j.dismissed_)j.execute();
> }
> catch(...){}
> }
> }
>
> mutable bool dismissed_;
>
>private:
> scope_guard_impl_base& operator=(const scope_guard_impl_base&);
>};
>
>typedef const scope_guard_impl_base& scope_guard;
>
>struct null_guard : public scope_guard_impl_base
>{
> template< class T1 >
> null_guard( const T1& )
> { }
>
> template< class T1, class T2 >
> null_guard( const T1&, const T2& )
> { }
>
> template< class T1, class T2, class T3 >
> null_guard( const T1&, const T2&, const T3& )
> { }
>
> template< class T1, class T2, class T3, class T4 >
> null_guard( const T1&, const T2&, const T3&, const T4& )
> { }
>
> template< class T1, class T2, class T3, class T4, class T5 >
> null_guard( const T1&, const T2&, const T3&, const T4&, const T5& )
> { }
>};
>
>template< bool cond, class T >
>struct null_guard_return
>{
> typedef typename boost::mpl::if_c<cond,T,null_guard>::type type;
>};
>
>template<typename F>
>class scope_guard_impl0:public scope_guard_impl_base
>{
>public:
> scope_guard_impl0(F fun):fun_(fun){}
> ~scope_guard_impl0(){scope_guard_impl_base::safe_execute(*this);}
> void execute(){fun_();}
>
>protected:
>
> F fun_;
>};
>
>template<typename F>
>inline scope_guard_impl0<F> make_guard(F fun)
>{
> return scope_guard_impl0<F>(fun);
>}
>
>template<bool cond, typename F>
>inline typename null_guard_return<cond,scope_guard_impl0<F> >::type
>make_guard_if_c(F fun)
>{
> return typename null_guard_return<cond,scope_guard_impl0<F> >::type(fun);
>}
>
>template<typename C, typename F>
>inline typename null_guard_return<C::value,scope_guard_impl0<F> >::type
>make_guard_if(F fun)
>{
> return make_guard_if<C::value>(fun);
>}
>
>template<typename F,typename P1>
>class scope_guard_impl1:public scope_guard_impl_base
>{
>public:
> scope_guard_impl1(F fun,P1 p1):fun_(fun),p1_(p1){}
> ~scope_guard_impl1(){scope_guard_impl_base::safe_execute(*this);}
> void execute(){fun_(p1_);}
>
>protected:
> F fun_;
> const P1 p1_;
>};
>
>template<typename F,typename P1>
>inline scope_guard_impl1<F,P1> make_guard(F fun,P1 p1)
>{
> return scope_guard_impl1<F,P1>(fun,p1);
>}
>
>template<bool cond, typename F,typename P1>
>inline typename null_guard_return<cond,scope_guard_impl1<F,P1> >::type
>make_guard_if_c(F fun,P1 p1)
>{
> return typename null_guard_return<cond,scope_guard_impl1<F,P1> >::type(fun,p1);
>}
>
>template<typename C, typename F,typename P1>
>inline typename null_guard_return<C::value,scope_guard_impl1<F,P1> >::type
>make_guard_if(F fun,P1 p1)
>{
> return make_guard_if_c<C::value>(fun,p1);
>}
>
>template<typename F,typename P1,typename P2>
>class scope_guard_impl2:public scope_guard_impl_base
>{
>public:
> scope_guard_impl2(F fun,P1 p1,P2 p2):fun_(fun),p1_(p1),p2_(p2){}
> ~scope_guard_impl2(){scope_guard_impl_base::safe_execute(*this);}
> void execute(){fun_(p1_,p2_);}
>
>protected:
> F fun_;
> const P1 p1_;
> const P2 p2_;
>};
>
>template<typename F,typename P1,typename P2>
>inline scope_guard_impl2<F,P1,P2> make_guard(F fun,P1 p1,P2 p2)
>{
> return scope_guard_impl2<F,P1,P2>(fun,p1,p2);
>}
>
>template<bool cond, typename F,typename P1,typename P2>
>inline typename null_guard_return<cond,scope_guard_impl2<F,P1,P2> >::type
>make_guard_if_c(F fun,P1 p1,P2 p2)
>{
> return typename null_guard_return<cond,scope_guard_impl2<F,P1,P2> >::type(fun,p1,p2);
>}
>
>template<typename C, typename F,typename P1,typename P2>
>inline typename null_guard_return<C::value,scope_guard_impl2<F,P1,P2> >::type
>make_guard_if(F fun,P1 p1,P2 p2)
>{
> return make_guard_if_c<C::value>(fun,p1,p2);
>}
>
>template<typename F,typename P1,typename P2,typename P3>
>class scope_guard_impl3:public scope_guard_impl_base
>{
>public:
> scope_guard_impl3(F fun,P1 p1,P2 p2,P3 p3):fun_(fun),p1_(p1),p2_(p2),p3_(p3){}
> ~scope_guard_impl3(){scope_guard_impl_base::safe_execute(*this);}
> void execute(){fun_(p1_,p2_,p3_);}
>
>protected:
> F fun_;
> const P1 p1_;
> const P2 p2_;
> const P3 p3_;
>};
>
>template<typename F,typename P1,typename P2,typename P3>
>inline scope_guard_impl3<F,P1,P2,P3> make_guard(F fun,P1 p1,P2 p2,P3 p3)
>{
> return scope_guard_impl3<F,P1,P2,P3>(fun,p1,p2,p3);
>}
>
>template<bool cond,typename F,typename P1,typename P2,typename P3>
>inline typename null_guard_return<cond,scope_guard_impl3<F,P1,P2,P3> >::type
>make_guard_if_c(F fun,P1 p1,P2 p2,P3 p3)
>{
> return typename null_guard_return<cond,scope_guard_impl3<F,P1,P2,P3> >::type(fun,p1,p2,p3);
>}
>
>template<typename C,typename F,typename P1,typename P2,typename P3>
>inline typename null_guard_return< C::value,scope_guard_impl3<F,P1,P2,P3> >::type
>make_guard_if(F fun,P1 p1,P2 p2,P3 p3)
>{
> return make_guard_if_c<C::value>(fun,p1,p2,p3);
>}
>
>template<typename F,typename P1,typename P2,typename P3,typename P4>
>class scope_guard_impl4:public scope_guard_impl_base
>{
>public:
> scope_guard_impl4(F fun,P1 p1,P2 p2,P3 p3,P4 p4):
> fun_(fun),p1_(p1),p2_(p2),p3_(p3),p4_(p4){}
> ~scope_guard_impl4(){scope_guard_impl_base::safe_execute(*this);}
> void execute(){fun_(p1_,p2_,p3_,p4_);}
>
>protected:
> F fun_;
> const P1 p1_;
> const P2 p2_;
> const P3 p3_;
> const P4 p4_;
>};
>
>template<typename F,typename P1,typename P2,typename P3,typename P4>
>inline scope_guard_impl4<F,P1,P2,P3,P4> make_guard(
> F fun,P1 p1,P2 p2,P3 p3,P4 p4)
>{
> return scope_guard_impl4<F,P1,P2,P3,P4>(fun,p1,p2,p3,p4);
>}
>
>template<bool cond, typename F,typename P1,typename P2,typename P3,typename P4>
>inline typename null_guard_return<cond,scope_guard_impl4<F,P1,P2,P3,P4> >::type
>make_guard_if_c(
> F fun,P1 p1,P2 p2,P3 p3,P4 p4)
>{
> return typename null_guard_return<cond,scope_guard_impl4<F,P1,P2,P3,P4> >::type(fun,p1,p2,p3,p4);
>}
>
>template<typename C, typename F,typename P1,typename P2,typename P3,typename P4>
>inline typename null_guard_return<C::value,scope_guard_impl4<F,P1,P2,P3,P4> >::type
>make_guard_if(
> F fun,P1 p1,P2 p2,P3 p3,P4 p4)
>{
> return make_guard_if_c<C::value>(fun,p1,p2,p3,p4);
>}
>
>template<class Obj,typename MemFun>
>class obj_scope_guard_impl0:public scope_guard_impl_base
>{
>public:
> obj_scope_guard_impl0(Obj& obj,MemFun mem_fun):obj_(obj),mem_fun_(mem_fun){}
> ~obj_scope_guard_impl0(){scope_guard_impl_base::safe_execute(*this);}
> void execute(){(obj_.*mem_fun_)();}
>
>protected:
> Obj& obj_;
> MemFun mem_fun_;
>};
>
>template<class Obj,typename MemFun>
>inline obj_scope_guard_impl0<Obj,MemFun> make_obj_guard(Obj& obj,MemFun mem_fun)
>{
> return obj_scope_guard_impl0<Obj,MemFun>(obj,mem_fun);
>}
>
>template<bool cond, class Obj,typename MemFun>
>inline typename null_guard_return<cond,obj_scope_guard_impl0<Obj,MemFun> >::type
>make_obj_guard_if_c(Obj& obj,MemFun mem_fun)
>{
> return typename null_guard_return<cond,obj_scope_guard_impl0<Obj,MemFun> >::type(obj,mem_fun);
>}
>
>template<typename C, class Obj,typename MemFun>
>inline typename null_guard_return<C::value,obj_scope_guard_impl0<Obj,MemFun> >::type
>make_obj_guard_if(Obj& obj,MemFun mem_fun)
>{
> return make_obj_guard_if_c<C::value>(obj,mem_fun);
>}
>
>template<class Obj,typename MemFun,typename P1>
>class obj_scope_guard_impl1:public scope_guard_impl_base
>{
>public:
> obj_scope_guard_impl1(Obj& obj,MemFun mem_fun,P1 p1):
> obj_(obj),mem_fun_(mem_fun),p1_(p1){}
> ~obj_scope_guard_impl1(){scope_guard_impl_base::safe_execute(*this);}
> void execute(){(obj_.*mem_fun_)(p1_);}
>
>protected:
> Obj& obj_;
> MemFun mem_fun_;
> const P1 p1_;
>};
>
>template<class Obj,typename MemFun,typename P1>
>inline obj_scope_guard_impl1<Obj,MemFun,P1> make_obj_guard(
> Obj& obj,MemFun mem_fun,P1 p1)
>{
> return obj_scope_guard_impl1<Obj,MemFun,P1>(obj,mem_fun,p1);
>}
>
>template<bool cond, class Obj,typename MemFun,typename P1>
>inline typename null_guard_return<cond,obj_scope_guard_impl1<Obj,MemFun,P1> >::type
>make_obj_guard_if_c( Obj& obj,MemFun mem_fun,P1 p1)
>{
> return typename null_guard_return<cond,obj_scope_guard_impl1<Obj,MemFun,P1> >::type(obj,mem_fun,p1);
>}
>
>template<typename C, class Obj,typename MemFun,typename P1>
>inline typename null_guard_return<C::value,obj_scope_guard_impl1<Obj,MemFun,P1> >::type
>make_obj_guard_if( Obj& obj,MemFun mem_fun,P1 p1)
>{
> return make_obj_guard_if_c<C::value>(obj,mem_fun,p1);
>}
>
>template<class Obj,typename MemFun,typename P1,typename P2>
>class obj_scope_guard_impl2:public scope_guard_impl_base
>{
>public:
> obj_scope_guard_impl2(Obj& obj,MemFun mem_fun,P1 p1,P2 p2):
> obj_(obj),mem_fun_(mem_fun),p1_(p1),p2_(p2)
> {}
> ~obj_scope_guard_impl2(){scope_guard_impl_base::safe_execute(*this);}
> void execute(){(obj_.*mem_fun_)(p1_,p2_);}
>
>protected:
> Obj& obj_;
> MemFun mem_fun_;
> const P1 p1_;
> const P2 p2_;
>};
>
>template<class Obj,typename MemFun,typename P1,typename P2>
>inline obj_scope_guard_impl2<Obj,MemFun,P1,P2>
>make_obj_guard(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
>{
> return obj_scope_guard_impl2<Obj,MemFun,P1,P2>(obj,mem_fun,p1,p2);
>}
>
>template<bool cond, class Obj,typename MemFun,typename P1,typename P2>
>inline typename null_guard_return<cond,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type
>make_obj_guard_if_c(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
>{
> return typename null_guard_return<cond,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type(obj,mem_fun,p1,p2);
>}
>
>template<typename C, class Obj,typename MemFun,typename P1,typename P2>
>inline typename null_guard_return<C::value,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type
>make_obj_guard_if(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
>{
> return make_obj_guard_if_c<C::value>(obj,mem_fun,p1,p2);
>}
>
>template<class Obj,typename MemFun,typename P1,typename P2,typename P3>
>class obj_scope_guard_impl3:public scope_guard_impl_base
>{
>public:
> obj_scope_guard_impl3(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3):
> obj_(obj),mem_fun_(mem_fun),p1_(p1),p2_(p2),p3_(p3)
> {}
> ~obj_scope_guard_impl3(){scope_guard_impl_base::safe_execute(*this);}
> void execute(){(obj_.*mem_fun_)(p1_,p2_,p3_);}
>
>protected:
> Obj& obj_;
> MemFun mem_fun_;
> const P1 p1_;
> const P2 p2_;
> const P3 p3_;
>};
>
>template<class Obj,typename MemFun,typename P1,typename P2,typename P3>
>inline obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3>
>make_obj_guard(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
>{
> return obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3>(obj,mem_fun,p1,p2,p3);
>}
>
>template<bool cond, class Obj,typename MemFun,typename P1,typename P2,typename P3>
>inline typename null_guard_return<cond,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type
>make_obj_guard_if_c(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
>{
> return typename null_guard_return<cond,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type(obj,mem_fun,p1,p2,p3);
>}
>
>template<typename C, class Obj,typename MemFun,typename P1,typename P2,typename P3>
>inline typename null_guard_return<C::value,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type
>make_obj_guard_if(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
>{
> return make_obj_guard_if_c<C::value>(obj,mem_fun,p1,p2,p3);
>}
>
>}
>
>}
>
>}
># 41 "/usr/include/boost/multi_index_container.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/utility/base_from_member.hpp" 1 3 4
># 16 "/usr/include/boost/utility/base_from_member.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 1 3 4
># 23 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
># 24 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 2 3 4
># 17 "/usr/include/boost/utility/base_from_member.hpp" 2 3 4
># 53 "/usr/include/boost/utility/base_from_member.hpp" 3 4
>namespace boost
>{
># 65 "/usr/include/boost/utility/base_from_member.hpp" 3 4
>template < typename MemberType, int UniqueID = 0 >
>class base_from_member
>{
>protected:
> MemberType member;
>
> base_from_member()
> : member()
> {}
>
> template < typename T0 > explicit base_from_member( T0 x0 ) : member( x0 ) {} template < typename T0 , typename T1 > explicit base_from_member( T0 x0 , T1 x1 ) : member( x0 , x1 ) {} template < typename T0 , typename T1 , typename T2 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 ) : member( x0 , x1 , x2 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 ) : member( x0 , x1 , x2 , x3 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 ) : member( x0 , x1 , x2 , x3 , x4 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 ) : member( x0 , x1 , x2 , x3 , x4 , x5 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 , T8 x8 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 , T8 x8 , T9 x9 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 ) {}
>
>
>};
>
>}
># 44 "/usr/include/boost/multi_index_container.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/multi_index/detail/archive_constructed.hpp" 1 3 4
># 19 "/usr/include/boost/multi_index/detail/archive_constructed.hpp" 3 4
># 1 "/usr/include/boost/serialization/serialization.hpp" 1 3 4
># 14 "/usr/include/boost/serialization/serialization.hpp" 3 4
># 1 "/usr/include/boost/serialization/strong_typedef.hpp" 1 3 4
># 15 "/usr/include/boost/serialization/serialization.hpp" 2 3 4
># 59 "/usr/include/boost/serialization/serialization.hpp" 3 4
>namespace boost {
>namespace serialization {
>
>struct version_type : boost::totally_ordered1< version_type , boost::totally_ordered2< version_type, unsigned int > > { unsigned int t; explicit version_type(const unsigned int t_) : t(t_) {}; version_type(): t() {}; version_type(const version_type & t_) : t(t_.t){} version_type & operator=(const version_type & rhs) { t = rhs.t; return *this;} version_type & operator=(const unsigned int & rhs) { t = rhs; return *this;} operator const unsigned int & () const {return t; } operator unsigned int & () { return t; } bool operator==(const version_type & rhs) const { return t == rhs.t; } bool operator<(const version_type & rhs) const { return t < rhs.t; } };
>
>
>template<class Archive, class T>
>inline void serialize(
> Archive & ar, T & t, const unsigned int file_version
>){
> access::serialize(ar, t, static_cast<unsigned int>(file_version));
>}
>
>
>template<class Archive, class T>
>inline void save_construct_data(
> Archive & ,
> const T * ,
> const unsigned int
>){
>
>
>}
>
>
>template<class Archive, class T>
>inline void load_construct_data(
> Archive & ,
> T * t,
> const unsigned int
>){
>
>
>
> access::construct(t);
>}
># 112 "/usr/include/boost/serialization/serialization.hpp" 3 4
>template<class Archive, class T>
>inline void serialize_adl(
> Archive & ar,
> T & t,
> const unsigned int file_version
>){
># 127 "/usr/include/boost/serialization/serialization.hpp" 3 4
> const version_type v(file_version);
> serialize(ar, t, v);
>
>
>
>}
>
>template<class Archive, class T>
>inline void save_construct_data_adl(
> Archive & ar,
> const T * t,
> const unsigned int file_version
>){
>
>
> const version_type v(file_version);
> save_construct_data(ar, t, v);
>
>
>
>}
>
>template<class Archive, class T>
>inline void load_construct_data_adl(
> Archive & ar,
> T * t,
> const unsigned int file_version
>){
>
>
> const version_type v(file_version);
> load_construct_data(ar, t, v);
>
>
>
>}
>
>}
>}
># 20 "/usr/include/boost/multi_index/detail/archive_constructed.hpp" 2 3 4
>
>
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>
>
>template<typename T>
>struct archive_constructed:private noncopyable
>{
> template<class Archive>
> archive_constructed(Archive& ar,const unsigned int version)
> {
> serialization::load_construct_data_adl(ar,&get(),version);
> { try{
> ar>>get();
> }
> catch(...){
> (&get())->~T();
> throw;;
> }
> }
> }
>
> template<class Archive>
> archive_constructed(const char* name,Archive& ar,const unsigned int version)
> {
> serialization::load_construct_data_adl(ar,&get(),version);
> { try{
> ar>>serialization::make_nvp(name,get());
> }
> catch(...){
> (&get())->~T();
> throw;;
> }
> }
> }
>
> ~archive_constructed()
> {
> (&get())->~T();
> }
>
> T& get(){return *static_cast<T*>(static_cast<void*>(&space));}
>
>private:
> typename aligned_storage<sizeof(T),alignment_of<T>::value>::type space;
>};
>
>}
>
>}
>
>}
># 47 "/usr/include/boost/multi_index_container.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/detail/serialization_version.hpp" 1 3 4
># 18 "/usr/include/boost/multi_index/detail/serialization_version.hpp" 3 4
># 1 "/usr/include/boost/serialization/version.hpp" 1 3 4
># 28 "/usr/include/boost/serialization/version.hpp" 3 4
>namespace boost {
>namespace serialization {
>
>struct basic_traits;
>
>
>
>template<class T>
>struct version
>{
> template<class U>
> struct traits_class_version {
> typedef typename U::version type;
> };
>
> typedef mpl::integral_c_tag tag;
>
>
> typedef
> typename mpl::eval_if<
> is_base_and_derived<boost::serialization::basic_traits,T>,
> traits_class_version< T >,
> mpl::int_<0>
> >::type type;
> static const int value = version::type::value;
>};
>
>
>template<class T>
>const int version<T>::value;
>
>
>}
>}
># 76 "/usr/include/boost/serialization/version.hpp" 3 4
># 1 "/usr/include/boost/mpl/comparison.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/comparison.hpp" 3 4
># 1 "/usr/include/boost/mpl/not_equal_to.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/not_equal_to.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
># 27 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
># 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename Tag1
> , typename Tag2
> >
>struct not_equal_to_impl
> : if_c<
> ( Tag1::value
> > Tag2::value
> )
>
> , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 >
> , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 >
> >::type
>{
>};
>
>
>template<> struct not_equal_to_impl< na,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct not_equal_to_impl< na,Tag >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct not_equal_to_impl< Tag,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename T > struct not_equal_to_tag
>{
> typedef typename T::tag type;
>};
>
>template<
> typename N1 = na
> , typename N2 = na
> >
>struct not_equal_to
>
> : not_equal_to_impl<
> typename not_equal_to_tag<N1>::type
> , typename not_equal_to_tag<N2>::type
> >::template apply< N1,N2 >::type
>{
> 
>
>};
>
>template<> struct not_equal_to< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : not_equal_to< T1 , T2 > { }; }; template< typename Tag > struct lambda< not_equal_to< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef not_equal_to< na , na > result_; typedef not_equal_to< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< not_equal_to< T1 , T2 > > : int_<2> { }; template<> struct template_arity< not_equal_to< na , na > > : int_<-1> { }; }
>
>}}
>
>namespace boost { namespace mpl {
>
>template<>
>struct not_equal_to_impl< integral_c_tag,integral_c_tag >
>{
> template< typename N1, typename N2 > struct apply
>
> : bool_< ( N1::value != N2::value ) >
> {
> };
>};
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
># 20 "/usr/include/boost/mpl/not_equal_to.hpp" 2 3 4
># 19 "/usr/include/boost/mpl/comparison.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/less_equal.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/less_equal.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
># 27 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
># 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename Tag1
> , typename Tag2
> >
>struct less_equal_impl
> : if_c<
> ( Tag1::value
> > Tag2::value
> )
>
> , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 >
> , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 >
> >::type
>{
>};
>
>
>template<> struct less_equal_impl< na,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct less_equal_impl< na,Tag >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct less_equal_impl< Tag,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename T > struct less_equal_tag
>{
> typedef typename T::tag type;
>};
>
>template<
> typename N1 = na
> , typename N2 = na
> >
>struct less_equal
>
> : less_equal_impl<
> typename less_equal_tag<N1>::type
> , typename less_equal_tag<N2>::type
> >::template apply< N1,N2 >::type
>{
> 
>
>};
>
>template<> struct less_equal< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : less_equal< T1 , T2 > { }; }; template< typename Tag > struct lambda< less_equal< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef less_equal< na , na > result_; typedef less_equal< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< less_equal< T1 , T2 > > : int_<2> { }; template<> struct template_arity< less_equal< na , na > > : int_<-1> { }; }
>
>}}
>
>namespace boost { namespace mpl {
>
>template<>
>struct less_equal_impl< integral_c_tag,integral_c_tag >
>{
> template< typename N1, typename N2 > struct apply
>
> : bool_< ( N1::value <= N2::value ) >
> {
> };
>};
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
># 20 "/usr/include/boost/mpl/less_equal.hpp" 2 3 4
># 22 "/usr/include/boost/mpl/comparison.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/greater_equal.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/greater_equal.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
># 27 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
># 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
># 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
># 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp" 1 3 4
># 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp" 3 4
>namespace boost { namespace mpl {
>
>template<
> typename Tag1
> , typename Tag2
> >
>struct greater_equal_impl
> : if_c<
> ( Tag1::value
> > Tag2::value
> )
>
> , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 >
> , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 >
> >::type
>{
>};
>
>
>template<> struct greater_equal_impl< na,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct greater_equal_impl< na,Tag >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename Tag > struct greater_equal_impl< Tag,na >
>{
> template< typename U1, typename U2 > struct apply
> {
> typedef apply type;
> static const int value = 0;
> };
>};
>
>template< typename T > struct greater_equal_tag
>{
> typedef typename T::tag type;
>};
>
>template<
> typename N1 = na
> , typename N2 = na
> >
>struct greater_equal
>
> : greater_equal_impl<
> typename greater_equal_tag<N1>::type
> , typename greater_equal_tag<N2>::type
> >::template apply< N1,N2 >::type
>{
> 
>
>};
>
>template<> struct greater_equal< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : greater_equal< T1 , T2 > { }; }; template< typename Tag > struct lambda< greater_equal< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef greater_equal< na , na > result_; typedef greater_equal< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< greater_equal< T1 , T2 > > : int_<2> { }; template<> struct template_arity< greater_equal< na , na > > : int_<-1> { }; }
>
>}}
>
>namespace boost { namespace mpl {
>
>template<>
>struct greater_equal_impl< integral_c_tag,integral_c_tag >
>{
> template< typename N1, typename N2 > struct apply
>
> : bool_< ( N1::value >= N2::value ) >
> {
> };
>};
>
>}}
># 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
># 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
># 20 "/usr/include/boost/mpl/greater_equal.hpp" 2 3 4
># 23 "/usr/include/boost/mpl/comparison.hpp" 2 3 4
># 77 "/usr/include/boost/serialization/version.hpp" 2 3 4
># 19 "/usr/include/boost/multi_index/detail/serialization_version.hpp" 2 3 4
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>
>
>
>
>
>
>template<typename T>
>struct serialization_version
>{
> serialization_version():
> value(boost::serialization::version<serialization_version>::value){}
>
> serialization_version& operator=(unsigned int x){value=x;return *this;};
>
> operator unsigned int()const{return value;}
>
>private:
> friend class boost::serialization::access;
>
> template<class Archive> void serialize( Archive &ar, const unsigned int file_version ){ boost::serialization::split_member(ar, *this, file_version); }
>
> template<class Archive>
> void save(Archive&,const unsigned int)const{}
>
> template<class Archive>
> void load(Archive&,const unsigned int version)
> {
> this->value=version;
> }
>
> unsigned int value;
>};
>
>}
>
>}
>
>
>namespace serialization {
>template<typename T>
>struct version<boost::multi_index::detail::serialization_version<T> >
>{
> static const int value=version<T>::value;
>};
>}
>
>
>}
># 48 "/usr/include/boost/multi_index_container.hpp" 2 3 4
># 1 "/usr/include/boost/serialization/collection_size_type.hpp" 1 3 4
># 9 "/usr/include/boost/serialization/collection_size_type.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 10 "/usr/include/boost/serialization/collection_size_type.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/serialization/split_free.hpp" 1 3 4
># 24 "/usr/include/boost/serialization/split_free.hpp" 3 4
>namespace boost {
>namespace archive {
> namespace detail {
> template<class Archive> class interface_oarchive;
> template<class Archive> class interface_iarchive;
> }
>}
>
>namespace serialization {
>
>
>template<class Archive, class T>
>struct free_saver {
> static void invoke(
> Archive & ar,
> const T & t,
> const unsigned int file_version
> ){
>
>
> const version_type v(file_version);
> save(ar, t, v);
> }
>};
>template<class Archive, class T>
>struct free_loader {
> static void invoke(
> Archive & ar,
> T & t,
> const unsigned int file_version
> ){
>
>
> const version_type v(file_version);
> load(ar, t, v);
> }
>};
>
>
>template<class Archive, class T>
>inline void split_free(
> Archive & ar,
> T & t,
> const unsigned int file_version
>){
> typedef typename mpl::eval_if<
> typename Archive::is_saving,
> mpl::identity< free_saver<Archive, T> >,
> mpl::identity< free_loader<Archive, T> >
> >::type typex;
> typex::invoke(ar, t, file_version);
>}
>
>}
>}
># 13 "/usr/include/boost/serialization/collection_size_type.hpp" 2 3 4
># 1 "/usr/include/boost/serialization/is_bitwise_serializable.hpp" 1 3 4
># 27 "/usr/include/boost/serialization/is_bitwise_serializable.hpp" 3 4
>namespace boost {
>namespace serialization {
> template<class T>
> struct is_bitwise_serializable
> : public is_arithmetic< T >
> {};
>}
>}
># 14 "/usr/include/boost/serialization/collection_size_type.hpp" 2 3 4
>
>namespace boost {
>namespace serialization {
>
>
>
>class collection_size_type {
>private:
> typedef std::size_t base_type;
> base_type t;
>public:
> collection_size_type(): t(0) {};
> explicit collection_size_type(const std::size_t & t_) :
> t(t_)
> {}
> collection_size_type(const collection_size_type & t_) :
> t(t_.t)
> {}
> collection_size_type & operator=(const collection_size_type & rhs){
> t = rhs.t;
> return *this;
> }
> collection_size_type & operator=(const unsigned int & rhs){
> t = rhs;
> return *this;
> }
>
> operator base_type () const {
> return t;
> }
>
> operator base_type & () {
> return t;
> }
> bool operator==(const collection_size_type & rhs) const {
> return t == rhs.t;
> }
> bool operator<(const collection_size_type & rhs) const {
> return t < rhs.t;
> }
>};
>
>
>} }
>
>namespace boost { namespace serialization { template <> struct implementation_level_impl< const collection_size_type > { typedef mpl::integral_c_tag tag; typedef mpl::int_< primitive_type > type; static const int value = implementation_level_impl::type::value; }; } }
>namespace boost { namespace serialization { template<> struct is_bitwise_serializable< collection_size_type > : mpl::true_ {}; }}
># 49 "/usr/include/boost/multi_index_container.hpp" 2 3 4
># 65 "/usr/include/boost/multi_index_container.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>template<typename Value,typename IndexSpecifierList,typename Allocator>
>class multi_index_container:
> private ::boost::base_from_member<
> typename boost::detail::allocator::rebind_to<
> Allocator,
> typename detail::multi_index_node_type<
> Value,IndexSpecifierList,Allocator>::type
> >::type>,
> private detail::header_holder<
> typename detail::prevent_eti<
> Allocator,
> typename boost::detail::allocator::rebind_to<
> Allocator,
> typename detail::multi_index_node_type<
> Value,IndexSpecifierList,Allocator>::type
> >::type
> >::type::pointer,
> multi_index_container<Value,IndexSpecifierList,Allocator> >,
> public detail::multi_index_base_type<
> Value,IndexSpecifierList,Allocator>::type
>{
># 100 "/usr/include/boost/multi_index_container.hpp" 3 4
>private:
>
> template <typename,typename,typename> friend class detail::index_base;
> template <typename,typename> friend struct detail::header_holder;
> template <typename,typename> friend struct detail::converter;
>
>
> typedef typename detail::multi_index_base_type<
> Value,IndexSpecifierList,Allocator>::type super;
> typedef typename
> boost::detail::allocator::rebind_to<
> Allocator,
> typename super::node_type
> >::type node_allocator;
> typedef ::boost::base_from_member<
> node_allocator> bfm_allocator;
> typedef detail::header_holder<
> typename detail::prevent_eti<
> Allocator,
> node_allocator
> >::type::pointer,
> multi_index_container> bfm_header;
>
>
>
>
>
>
>public:
>
>
>
>
> typedef typename super::ctor_args_list ctor_args_list;
> typedef IndexSpecifierList index_specifier_type_list;
># 155 "/usr/include/boost/multi_index_container.hpp" 3 4
> typedef typename super::index_type_list index_type_list;
>
>
> typedef typename super::iterator_type_list iterator_type_list;
> typedef typename super::const_iterator_type_list const_iterator_type_list;
> typedef typename super::value_type value_type;
> typedef typename super::final_allocator_type allocator_type;
> typedef typename super::iterator iterator;
> typedef typename super::const_iterator const_iterator;
>
> static_assert(detail::no_duplicate_tags_in_index_list<index_type_list>::value, "detail::no_duplicate_tags_in_index_list<index_type_list>::value")
> ;
>
>
>
> typedef typename super::node_type node_type;
>
>
>
> explicit multi_index_container(
># 188 "/usr/include/boost/multi_index_container.hpp" 3 4
> const ctor_args_list& args_list=ctor_args_list(),
> const allocator_type& al=allocator_type()):
>
>
> bfm_allocator(al),
> super(args_list,bfm_allocator::member),
> node_count(0)
> {
> ;
> }
>
> explicit multi_index_container(const allocator_type& al):
> bfm_allocator(al),
> super(ctor_args_list(),bfm_allocator::member),
> node_count(0)
> {
> ;
> }
>
> template<typename InputIterator>
> multi_index_container(
> InputIterator first,InputIterator last,
># 223 "/usr/include/boost/multi_index_container.hpp" 3 4
> const ctor_args_list& args_list=ctor_args_list(),
> const allocator_type& al=allocator_type()):
>
>
> bfm_allocator(al),
> super(args_list,bfm_allocator::member),
> node_count(0)
> {
> ;
> { try{
> iterator hint=super::end();
> for(;first!=last;++first){
> hint=super::make_iterator(insert_(*first,hint.get_node()).first);
> }
> }
> catch(...){
> clear_();
> throw;;
> }
> }
> }
>
> multi_index_container(
> const multi_index_container<Value,IndexSpecifierList,Allocator>& x):
> bfm_allocator(x.bfm_allocator::member),
> bfm_header(),
> super(x),
> node_count(0)
> {
> copy_map_type map(bfm_allocator::member,x.size(),x.header(),header());
> for(const_iterator it=x.begin(),it_end=x.end();it!=it_end;++it){
> map.clone(it.get_node());
> }
> super::copy_(x,map);
> map.release();
> node_count=x.size();
>
>
>
>
>
> ;
> }
>
> ~multi_index_container()
> {
> delete_all_nodes_();
> }
>
> multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
> multi_index_container<Value,IndexSpecifierList,Allocator> x)
> {
> ;
> this->swap(x);
> return *this;
> }
>
> allocator_type get_allocator()const
> {
> return allocator_type(bfm_allocator::member);
> }
>
>
>
>
> template<int N>
> struct nth_index
> {
> static_assert(N>=0&&N<mpl::size<index_type_list>::type::value, "N>=0&&N<mpl::size<index_type_list>::type::value");
> typedef typename mpl::at_c<index_type_list,N>::type type;
> };
>
> template<int N>
> typename nth_index<N>::type& get()
> {
> static_assert(N>=0&&N<mpl::size<index_type_list>::type::value, "N>=0&&N<mpl::size<index_type_list>::type::value");
> return *this;
> }
>
> template<int N>
> const typename nth_index<N>::type& get(
> )const
> {
> static_assert(N>=0&&N<mpl::size<index_type_list>::type::value, "N>=0&&N<mpl::size<index_type_list>::type::value");
> return *this;
> }
>
>
>
>
>
> template<typename Tag>
> struct index
> {
> typedef typename mpl::find_if<
> index_type_list,
> detail::has_tag<Tag>
> >::type iter;
>
> static const bool index_found=!(is_same<iter,typename mpl::end<index_type_list>::type >::value)
> ;
> static_assert(index_found, "index_found");
>
> typedef typename mpl::deref<iter>::type type;
> };
>
> template<typename Tag>
> typename index<Tag>::type& get()
> {
> return *this;
> }
>
> template<typename Tag>
> const typename index<Tag>::type& get(
> )const
> {
> return *this;
> }
>
>
>
>
>
> template<int N>
> struct nth_index_iterator
> {
> typedef typename nth_index<N>::type::iterator type;
> };
>
> template<int N>
> struct nth_index_const_iterator
> {
> typedef typename nth_index<N>::type::const_iterator type;
> };
>
> template<int N,typename IteratorType>
> typename nth_index_iterator<N>::type project(
> IteratorType it
> )
> {
> typedef typename nth_index<N>::type index;
>
>
> static_assert((mpl::contains<iterator_type_list,IteratorType>::value), "(mpl::contains<iterator_type_list,IteratorType>::value)")
> ;
>
>
> ((void)0);;
> ((void)0);
> ;
>
> return index::make_iterator(static_cast<node_type*>(it.get_node()));
> }
>
> template<int N,typename IteratorType>
> typename nth_index_const_iterator<N>::type project(
> IteratorType it
> )const
> {
> typedef typename nth_index<N>::type index;
>
>
> static_assert(( mpl::contains<iterator_type_list,IteratorType>::value|| mpl::contains<const_iterator_type_list,IteratorType>::value), "( mpl::contains<iterator_type_list,IteratorType>::value|| mpl::contains<const_iterator_type_list,IteratorType>::value)")
>
> ;
>
>
> ((void)0);;
> ((void)0);
> ;
> return index::make_iterator(static_cast<node_type*>(it.get_node()));
> }
>
>
>
>
>
> template<typename Tag>
> struct index_iterator
> {
> typedef typename index<Tag>::type::iterator type;
> };
>
> template<typename Tag>
> struct index_const_iterator
> {
> typedef typename index<Tag>::type::const_iterator type;
> };
>
> template<typename Tag,typename IteratorType>
> typename index_iterator<Tag>::type project(
> IteratorType it
> )
> {
> typedef typename index<Tag>::type index;
>
>
> static_assert((mpl::contains<iterator_type_list,IteratorType>::value), "(mpl::contains<iterator_type_list,IteratorType>::value)")
> ;
>
>
> ((void)0);;
> ((void)0);
> ;
> return index::make_iterator(static_cast<node_type*>(it.get_node()));
> }
>
> template<typename Tag,typename IteratorType>
> typename index_const_iterator<Tag>::type project(
> IteratorType it
> )const
> {
> typedef typename index<Tag>::type index;
>
>
> static_assert(( mpl::contains<iterator_type_list,IteratorType>::value|| mpl::contains<const_iterator_type_list,IteratorType>::value), "( mpl::contains<iterator_type_list,IteratorType>::value|| mpl::contains<const_iterator_type_list,IteratorType>::value)")
>
> ;
>
>
> ((void)0);;
> ((void)0);
> ;
> return index::make_iterator(static_cast<node_type*>(it.get_node()));
> }
>
>
>protected:
> typedef typename super::copy_map_type copy_map_type;
>
> node_type* header()const
> {
> return &*bfm_header::member;
> }
>
> node_type* allocate_node()
> {
> return &*bfm_allocator::member.allocate(1);
> }
>
> void deallocate_node(node_type* x)
> {
> typedef typename node_allocator::pointer node_pointer;
> bfm_allocator::member.deallocate(static_cast<node_pointer>(x),1);
> }
>
> bool empty_()const
> {
> return node_count==0;
> }
>
> std::size_t size_()const
> {
> return node_count;
> }
>
> std::size_t max_size_()const
> {
> return static_cast<std::size_t >(-1);
> }
>
> std::pair<node_type*,bool> insert_(const Value& v)
> {
> node_type* x=allocate_node();
> { try{
> node_type* res=super::insert_(v,x);
> if(res==x){
> ++node_count;
> return std::pair<node_type*,bool>(res,true);
> }
> else{
> deallocate_node(x);
> return std::pair<node_type*,bool>(res,false);
> }
> }
> catch(...){
> deallocate_node(x);
> throw;;
> }
> }
> }
>
> std::pair<node_type*,bool> insert_(const Value& v,node_type* position)
> {
> node_type* x=allocate_node();
> { try{
> node_type* res=super::insert_(v,position,x);
> if(res==x){
> ++node_count;
> return std::pair<node_type*,bool>(res,true);
> }
> else{
> deallocate_node(x);
> return std::pair<node_type*,bool>(res,false);
> }
> }
> catch(...){
> deallocate_node(x);
> throw;;
> }
> }
> }
>
> void erase_(node_type* x)
> {
> --node_count;
> super::erase_(x);
> deallocate_node(x);
> }
>
> void delete_node_(node_type* x)
> {
> super::delete_node_(x);
> deallocate_node(x);
> }
>
> void delete_all_nodes_()
> {
> super::delete_all_nodes_();
> }
>
> void clear_()
> {
> delete_all_nodes_();
> super::clear_();
> node_count=0;
> }
>
> void swap_(multi_index_container<Value,IndexSpecifierList,Allocator>& x)
> {
> if(bfm_allocator::member!=x.bfm_allocator::member){
> detail::adl_swap(bfm_allocator::member,x.bfm_allocator::member);
> }
> std::swap(bfm_header::member,x.bfm_header::member);
> super::swap_(x);
> std::swap(node_count,x.node_count);
> }
>
> bool replace_(const Value& k,node_type* x)
> {
> return super::replace_(k,x);
> }
>
> template<typename Modifier>
> bool modify_(Modifier& mod,node_type* x)
> {
> mod(const_cast<value_type&>(x->value()));
>
> { try{
> if(!super::modify_(x)){
> deallocate_node(x);
> --node_count;
> return false;
> }
> else return true;
> }
> catch(...){
> deallocate_node(x);
> --node_count;
> throw;;
> }
> }
> }
>
> template<typename Modifier,typename Rollback>
> bool modify_(Modifier& mod,Rollback& back,node_type* x)
> {
> mod(const_cast<value_type&>(x->value()));
>
> bool b;
> { try{
> b=super::modify_rollback_(x);
> }
> catch(...){
> { try{
> back(const_cast<value_type&>(x->value()));
> throw;;
> }
> catch(...){
> this->erase_(x);
> throw;;
> }
> }
> }
> }
>
> { try{
> if(!b){
> back(const_cast<value_type&>(x->value()));
> return false;
> }
> else return true;
> }
> catch(...){
> this->erase_(x);
> throw;;
> }
> }
> }
>
>
>
>
> friend class boost::serialization::access;
>
> template<class Archive> void serialize( Archive &ar, const unsigned int file_version ){ boost::serialization::split_member(ar, *this, file_version); }
>
> typedef typename super::index_saver_type index_saver_type;
> typedef typename super::index_loader_type index_loader_type;
>
> template<class Archive>
> void save(Archive& ar,const unsigned int version)const
> {
>
>
> const serialization::collection_size_type s(size_());
> const detail::serialization_version<value_type> value_version;
> ar<<serialization::make_nvp("count",s);
> ar<<serialization::make_nvp("value_version",value_version);
>
>
>
>
>
>
> index_saver_type sm(bfm_allocator::member,s);
>
> for(iterator it=super::begin(),it_end=super::end();it!=it_end;++it){
> serialization::save_construct_data_adl(ar,&*it,value_version);
> ar<<serialization::make_nvp("item",*it);
> sm.add(it.get_node(),ar,version);
> }
> sm.add_track(header(),ar,version);
>
> super::save_(ar,version,sm);
> }
>
> template<class Archive>
> void load(Archive& ar,const unsigned int version)
> {
> ;
>
> clear_();
>
>
> serialization::collection_size_type s;
> detail::serialization_version<value_type> value_version;
> if(version<1){
> std::size_t sz;
> ar>>serialization::make_nvp("count",sz);
> s=static_cast<serialization::collection_size_type>(sz);
> }
> else{
> ar>>serialization::make_nvp("count",s);
> }
> if(version<2){
> value_version=0;
> }
> else{
> ar>>serialization::make_nvp("value_version",value_version);
> }
>
>
>
>
>
>
> index_loader_type lm(bfm_allocator::member,s);
>
> for(std::size_t n=0;n<s;++n){
> detail::archive_constructed<Value> value("item",ar,value_version);
> std::pair<node_type*,bool> p=insert_(
> value.get(),super::end().get_node());
> if(!p.second)throw_exception(
> archive::archive_exception(
> archive::archive_exception::other_exception));
> ar.reset_object_address(&p.first->value(),&value.get());
> lm.add(p.first,ar,version);
> }
> lm.add_track(header(),ar,version);
>
> super::load_(ar,version,lm);
> }
># 722 "/usr/include/boost/multi_index_container.hpp" 3 4
>private:
> std::size_t node_count;
>
>
>
>
>
>};
>
>
>
>template<typename MultiIndexContainer,int N>
>struct nth_index
>{
> static const int M=mpl::size<typename MultiIndexContainer::index_type_list>::type::value
>
> ;
> static_assert(N>=0&&N<M, "N>=0&&N<M");
> typedef typename mpl::at_c<
> typename MultiIndexContainer::index_type_list,N>::type type;
>};
>
>template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
>typename nth_index<
> multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
>get(
> multi_index_container<Value,IndexSpecifierList,Allocator>& m
> )
>{
> typedef multi_index_container<
> Value,IndexSpecifierList,Allocator> multi_index_type;
> typedef typename nth_index<
> multi_index_container<
> Value,IndexSpecifierList,Allocator>,
> N
> >::type index;
>
> static_assert(N>=0&& N< mpl::size< typename multi_index_type::index_type_list >::type::value, "N>=0&& N< mpl::size< BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list >::type::value")
>
>
>
> ;
>
> return detail::converter<multi_index_type,index>::index(m);
>}
>
>template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
>const typename nth_index<
> multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
>get(
> const multi_index_container<Value,IndexSpecifierList,Allocator>& m
> )
>{
> typedef multi_index_container<
> Value,IndexSpecifierList,Allocator> multi_index_type;
> typedef typename nth_index<
> multi_index_container<
> Value,IndexSpecifierList,Allocator>,
> N
> >::type index;
>
> static_assert(N>=0&& N< mpl::size< typename multi_index_type::index_type_list >::type::value, "N>=0&& N< mpl::size< BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list >::type::value")
>
>
>
> ;
>
> return detail::converter<multi_index_type,index>::index(m);
>}
>
>
>
>template<typename MultiIndexContainer,typename Tag>
>struct index
>{
> typedef typename MultiIndexContainer::index_type_list index_type_list;
>
> typedef typename mpl::find_if<
> index_type_list,
> detail::has_tag<Tag>
> >::type iter;
>
> static const bool index_found=!(is_same<iter,typename mpl::end<index_type_list>::type >::value)
> ;
> static_assert(index_found, "index_found");
>
> typedef typename mpl::deref<iter>::type type;
>};
>
>template<
> typename Tag,typename Value,typename IndexSpecifierList,typename Allocator
>>
>typename ::boost::multi_index::index<
> multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
>get(
> multi_index_container<Value,IndexSpecifierList,Allocator>& m
> )
>{
> typedef multi_index_container<
> Value,IndexSpecifierList,Allocator> multi_index_type;
> typedef typename ::boost::multi_index::index<
> multi_index_container<
> Value,IndexSpecifierList,Allocator>,
> Tag
> >::type index;
>
> return detail::converter<multi_index_type,index>::index(m);
>}
>
>template<
> typename Tag,typename Value,typename IndexSpecifierList,typename Allocator
>>
>const typename ::boost::multi_index::index<
> multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
>get(
> const multi_index_container<Value,IndexSpecifierList,Allocator>& m
> )
>{
> typedef multi_index_container<
> Value,IndexSpecifierList,Allocator> multi_index_type;
> typedef typename ::boost::multi_index::index<
> multi_index_container<
> Value,IndexSpecifierList,Allocator>,
> Tag
> >::type index;
>
> return detail::converter<multi_index_type,index>::index(m);
>}
>
>
>
>template<typename MultiIndexContainer,int N>
>struct nth_index_iterator
>{
> typedef typename detail::prevent_eti<
> nth_index<MultiIndexContainer,N>,
> typename nth_index<MultiIndexContainer,N>::type>::type::iterator type;
>};
>
>template<typename MultiIndexContainer,int N>
>struct nth_index_const_iterator
>{
> typedef typename detail::prevent_eti<
> nth_index<MultiIndexContainer,N>,
> typename nth_index<MultiIndexContainer,N>::type
> >::type::const_iterator type;
>};
>
>template<
> int N,typename IteratorType,
> typename Value,typename IndexSpecifierList,typename Allocator>
>typename nth_index_iterator<
> multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
>project(
> multi_index_container<Value,IndexSpecifierList,Allocator>& m,
> IteratorType it
> )
>{
> typedef multi_index_container<
> Value,IndexSpecifierList,Allocator> multi_index_type;
> typedef typename nth_index<multi_index_type,N>::type index;
>
>
>
> static_assert(( mpl::contains< typename multi_index_type::iterator_type_list, IteratorType>::value), "( mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, IteratorType>::value)")
>
>
> ;
>
>
> ((void)0);;
># 901 "/usr/include/boost/multi_index_container.hpp" 3 4
> return detail::converter<multi_index_type,index>::iterator(
> m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
>}
>
>template<
> int N,typename IteratorType,
> typename Value,typename IndexSpecifierList,typename Allocator>
>typename nth_index_const_iterator<
> multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
>project(
> const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
> IteratorType it
> )
>{
> typedef multi_index_container<
> Value,IndexSpecifierList,Allocator> multi_index_type;
> typedef typename nth_index<multi_index_type,N>::type index;
>
>
>
> static_assert(( mpl::contains< typename multi_index_type::iterator_type_list, IteratorType>::value|| mpl::contains< typename multi_index_type::const_iterator_type_list, IteratorType>::value), "( mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, IteratorType>::value|| mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::const_iterator_type_list, IteratorType>::value)")
>
>
>
>
>
> ;
>
>
> ((void)0);;
># 939 "/usr/include/boost/multi_index_container.hpp" 3 4
> return detail::converter<multi_index_type,index>::const_iterator(
> m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
>}
>
>
>
>template<typename MultiIndexContainer,typename Tag>
>struct index_iterator
>{
> typedef typename ::boost::multi_index::index<
> MultiIndexContainer,Tag>::type::iterator type;
>};
>
>template<typename MultiIndexContainer,typename Tag>
>struct index_const_iterator
>{
> typedef typename ::boost::multi_index::index<
> MultiIndexContainer,Tag>::type::const_iterator type;
>};
>
>template<
> typename Tag,typename IteratorType,
> typename Value,typename IndexSpecifierList,typename Allocator>
>typename index_iterator<
> multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
>project(
> multi_index_container<Value,IndexSpecifierList,Allocator>& m,
> IteratorType it
> )
>{
> typedef multi_index_container<
> Value,IndexSpecifierList,Allocator> multi_index_type;
> typedef typename ::boost::multi_index::index<
> multi_index_type,Tag>::type index;
>
>
>
> static_assert(( mpl::contains< typename multi_index_type::iterator_type_list, IteratorType>::value), "( mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, IteratorType>::value)")
>
>
> ;
>
>
> ((void)0);;
># 991 "/usr/include/boost/multi_index_container.hpp" 3 4
> return detail::converter<multi_index_type,index>::iterator(
> m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
>}
>
>template<
> typename Tag,typename IteratorType,
> typename Value,typename IndexSpecifierList,typename Allocator>
>typename index_const_iterator<
> multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
>project(
> const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
> IteratorType it
> )
>{
> typedef multi_index_container<
> Value,IndexSpecifierList,Allocator> multi_index_type;
> typedef typename ::boost::multi_index::index<
> multi_index_type,Tag>::type index;
>
>
>
> static_assert(( mpl::contains< typename multi_index_type::iterator_type_list, IteratorType>::value|| mpl::contains< typename multi_index_type::const_iterator_type_list, IteratorType>::value), "( mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, IteratorType>::value|| mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::const_iterator_type_list, IteratorType>::value)")
>
>
>
>
>
> ;
>
>
> ((void)0);;
># 1030 "/usr/include/boost/multi_index_container.hpp" 3 4
> return detail::converter<multi_index_type,index>::const_iterator(
> m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
>}
>
>
>
>template<
> typename Value1,typename IndexSpecifierList1,typename Allocator1,
> typename Value2,typename IndexSpecifierList2,typename Allocator2
>>
>bool operator==(
> const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
> const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
>{
> return get<0>(x)==get<0>(y);
>}
>
>template<
> typename Value1,typename IndexSpecifierList1,typename Allocator1,
> typename Value2,typename IndexSpecifierList2,typename Allocator2
>>
>bool operator<(
> const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
> const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
>{
> return get<0>(x)<get<0>(y);
>}
>
>template<
> typename Value1,typename IndexSpecifierList1,typename Allocator1,
> typename Value2,typename IndexSpecifierList2,typename Allocator2
>>
>bool operator!=(
> const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
> const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
>{
> return get<0>(x)!=get<0>(y);
>}
>
>template<
> typename Value1,typename IndexSpecifierList1,typename Allocator1,
> typename Value2,typename IndexSpecifierList2,typename Allocator2
>>
>bool operator>(
> const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
> const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
>{
> return get<0>(x)>get<0>(y);
>}
>
>template<
> typename Value1,typename IndexSpecifierList1,typename Allocator1,
> typename Value2,typename IndexSpecifierList2,typename Allocator2
>>
>bool operator>=(
> const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
> const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
>{
> return get<0>(x)>=get<0>(y);
>}
>
>template<
> typename Value1,typename IndexSpecifierList1,typename Allocator1,
> typename Value2,typename IndexSpecifierList2,typename Allocator2
>>
>bool operator<=(
> const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
> const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
>{
> return get<0>(x)<=get<0>(y);
>}
>
>
>
>template<typename Value,typename IndexSpecifierList,typename Allocator>
>void swap(
> multi_index_container<Value,IndexSpecifierList,Allocator>& x,
> multi_index_container<Value,IndexSpecifierList,Allocator>& y)
>{
> x.swap(y);
>}
>
>}
># 1121 "/usr/include/boost/multi_index_container.hpp" 3 4
>namespace serialization {
>template<typename Value,typename IndexSpecifierList,typename Allocator>
>struct version<
> boost::multi_index_container<Value,IndexSpecifierList,Allocator>
>>
>{
> static const int value=2;
>};
>}
>
>
>
>
>
>
>using multi_index::get;
>using multi_index::project;
>
>}
># 22 "/usr/include/boost/property_tree/ptree.hpp" 2 3 4
>
># 1 "/usr/include/boost/multi_index/sequenced_index.hpp" 1 3 4
># 21 "/usr/include/boost/multi_index/sequenced_index.hpp" 3 4
># 1 "/usr/include/boost/foreach_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/foreach_fwd.hpp" 3 4
>enum boost_foreach_argument_dependent_lookup_hack
>{
> boost_foreach_argument_dependent_lookup_hack_value
>};
>
>namespace boost
>{
>
>namespace foreach
>{
>
>
>
> typedef boost_foreach_argument_dependent_lookup_hack tag;
>
>
>
>
>
> template<typename T>
> struct is_lightweight_proxy;
>
>
>
>
>
> template<typename T>
> struct is_noncopyable;
>
>}
>
>}
># 22 "/usr/include/boost/multi_index/sequenced_index.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/multi_index/detail/bidir_node_iterator.hpp" 1 3 4
># 24 "/usr/include/boost/multi_index/detail/bidir_node_iterator.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>
>
>
>
>template<typename Node>
>class bidir_node_iterator:
> public bidirectional_iterator_helper<
> bidir_node_iterator<Node>,
> typename Node::value_type,
> std::ptrdiff_t,
> const typename Node::value_type*,
> const typename Node::value_type&>
>{
>public:
> bidir_node_iterator(){}
> explicit bidir_node_iterator(Node* node_):node(node_){}
>
> const typename Node::value_type& operator*()const
> {
> return node->value();
> }
>
> bidir_node_iterator& operator++()
> {
> Node::increment(node);
> return *this;
> }
>
> bidir_node_iterator& operator--()
> {
> Node::decrement(node);
> return *this;
> }
>
>
>
>
>
>
> template<class Archive> void serialize( Archive &ar, const unsigned int file_version ){ boost::serialization::split_member(ar, *this, file_version); }
>
> typedef typename Node::base_type node_base_type;
>
> template<class Archive>
> void save(Archive& ar,const unsigned int)const
> {
> node_base_type* bnode=node;
> ar<<serialization::make_nvp("pointer",bnode);
> }
>
> template<class Archive>
> void load(Archive& ar,const unsigned int)
> {
> node_base_type* bnode;
> ar>>serialization::make_nvp("pointer",bnode);
> node=static_cast<Node*>(bnode);
> }
>
>
>
>
> typedef Node node_type;
>
> Node* get_node()const{return node;}
>
>private:
> Node* node;
>};
>
>template<typename Node>
>bool operator==(
> const bidir_node_iterator<Node>& x,
> const bidir_node_iterator<Node>& y)
>{
> return x.get_node()==y.get_node();
>}
>
>}
>
>}
>
>}
># 28 "/usr/include/boost/multi_index/sequenced_index.hpp" 2 3 4
>
># 1 "/usr/include/boost/multi_index/detail/safe_ctr_proxy.hpp" 1 3 4
># 30 "/usr/include/boost/multi_index/sequenced_index.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/multi_index/detail/seq_index_node.hpp" 1 3 4
># 21 "/usr/include/boost/multi_index/detail/seq_index_node.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>
>
>template<typename Allocator>
>struct sequenced_index_node_impl
>{
> typedef typename prevent_eti<
> Allocator,
> typename boost::detail::allocator::rebind_to<
> Allocator,sequenced_index_node_impl
> >::type
> >::type::pointer pointer;
> typedef typename prevent_eti<
> Allocator,
> typename boost::detail::allocator::rebind_to<
> Allocator,sequenced_index_node_impl
> >::type
> >::type::const_pointer const_pointer;
>
> pointer& prior(){return prior_;}
> pointer prior()const{return prior_;}
> pointer& next(){return next_;}
> pointer next()const{return next_;}
>
>
>
> static void increment(pointer& x){x=x->next();}
> static void decrement(pointer& x){x=x->prior();}
>
>
>
> static void link(pointer x,pointer header)
> {
> x->prior()=header->prior();
> x->next()=header;
> x->prior()->next()=x->next()->prior()=x;
> };
>
> static void unlink(pointer x)
> {
> x->prior()->next()=x->next();
> x->next()->prior()=x->prior();
> }
>
> static void relink(pointer position,pointer x)
> {
> unlink(x);
> x->prior()=position->prior();
> x->next()=position;
> x->prior()->next()=x->next()->prior()=x;
> }
>
> static void relink(pointer position,pointer x,pointer y)
> {
>
>
> if(x!=y){
> pointer z=y->prior();
> x->prior()->next()=y;
> y->prior()=x->prior();
> x->prior()=position->prior();
> z->next()=position;
> x->prior()->next()=x;
> z->next()->prior()=z;
> }
> }
>
> static void reverse(pointer header)
> {
> pointer x=header;
> do{
> pointer y=x->next();
> std::swap(x->prior(),x->next());
> x=y;
> }while(x!=header);
> }
>
> static void swap(pointer x,pointer y)
> {
>
>
>
>
>
> if(x->next()!=x){
> if(y->next()!=y){
> std::swap(x->next(),y->next());
> std::swap(x->prior(),y->prior());
> x->next()->prior()=x->prior()->next()=x;
> y->next()->prior()=y->prior()->next()=y;
> }
> else{
> y->next()=x->next();
> y->prior()=x->prior();
> x->next()=x->prior()=x;
> y->next()->prior()=y->prior()->next()=y;
> }
> }
> else if(y->next()!=y){
> x->next()=y->next();
> x->prior()=y->prior();
> y->next()=y->prior()=y;
> x->next()->prior()=x->prior()->next()=x;
> }
> }
>
>private:
> pointer prior_;
> pointer next_;
>};
>
>template<typename Super>
>struct sequenced_index_node_trampoline:
> prevent_eti<
> Super,
> sequenced_index_node_impl<
> typename boost::detail::allocator::rebind_to<
> typename Super::allocator_type,
> char
> >::type
> >
> >::type
>{
> typedef typename prevent_eti<
> Super,
> sequenced_index_node_impl<
> typename boost::detail::allocator::rebind_to<
> typename Super::allocator_type,
> char
> >::type
> >
> >::type impl_type;
>};
>
>template<typename Super>
>struct sequenced_index_node:Super,sequenced_index_node_trampoline<Super>
>{
>private:
> typedef sequenced_index_node_trampoline<Super> trampoline;
>
>public:
> typedef typename trampoline::impl_type impl_type;
> typedef typename trampoline::pointer impl_pointer;
> typedef typename trampoline::const_pointer const_impl_pointer;
>
> impl_pointer& prior(){return trampoline::prior();}
> impl_pointer prior()const{return trampoline::prior();}
> impl_pointer& next(){return trampoline::next();}
> impl_pointer next()const{return trampoline::next();}
>
> impl_pointer impl()
> {
> return static_cast<impl_pointer>(
> static_cast<impl_type*>(static_cast<trampoline*>(this)));
> }
>
> const_impl_pointer impl()const
> {
> return static_cast<const_impl_pointer>(
> static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
> }
>
> static sequenced_index_node* from_impl(impl_pointer x)
> {
> return static_cast<sequenced_index_node*>(
> static_cast<trampoline*>(&*x));
> }
>
> static const sequenced_index_node* from_impl(const_impl_pointer x)
> {
> return static_cast<const sequenced_index_node*>(
> static_cast<const trampoline*>(&*x));
> }
>
>
>
> static void increment(sequenced_index_node*& x)
> {
> impl_pointer xi=x->impl();
> trampoline::increment(xi);
> x=from_impl(xi);
> }
>
> static void decrement(sequenced_index_node*& x)
> {
> impl_pointer xi=x->impl();
> trampoline::decrement(xi);
> x=from_impl(xi);
> }
>};
>
>}
>
>}
>
>}
># 33 "/usr/include/boost/multi_index/sequenced_index.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/detail/seq_index_ops.hpp" 1 3 4
># 22 "/usr/include/boost/multi_index/detail/seq_index_ops.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 23 "/usr/include/boost/multi_index/detail/seq_index_ops.hpp" 2 3 4
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>
>
>
>
>template <typename SequencedIndex,typename Predicate>
>void sequenced_index_remove(SequencedIndex& x,Predicate pred)
>{
> typedef typename SequencedIndex::iterator iterator;
> iterator first=x.begin(),last=x.end();
> while(first!=last){
> if(pred(*first))x.erase(first++);
> else ++first;
> }
>}
>
>template <typename SequencedIndex,class BinaryPredicate>
>void sequenced_index_unique(SequencedIndex& x,BinaryPredicate binary_pred)
>{
> typedef typename SequencedIndex::iterator iterator;
> iterator first=x.begin();
> iterator last=x.end();
> if(first!=last){
> for(iterator middle=first;++middle!=last;middle=first){
> if(binary_pred(*middle,*first))x.erase(middle);
> else first=middle;
> }
> }
>}
>
>template <typename SequencedIndex,typename Compare>
>void sequenced_index_merge(SequencedIndex& x,SequencedIndex& y,Compare comp)
>{
> typedef typename SequencedIndex::iterator iterator;
> if(&x!=&y){
> iterator first0=x.begin(),last0=x.end();
> iterator first1=y.begin(),last1=y.end();
> while(first0!=last0&&first1!=last1){
> if(comp(*first1,*first0))x.splice(first0,y,first1++);
> else ++first0;
> }
> x.splice(last0,y,first1,last1);
> }
>}
>
>
>
>
>
>template<typename Node,typename Compare>
>void sequenced_index_collate(
> typename Node::impl_type* x,
> typename Node::impl_type* y,
> Compare comp
> )
>{
> typedef typename Node::impl_type impl_type;
> typedef typename Node::impl_pointer impl_pointer;
>
> impl_pointer first0=x->next();
> impl_pointer last0=x;
> impl_pointer first1=y->next();
> impl_pointer last1=y;
> while(first0!=last0&&first1!=last1){
> if(comp(
> Node::from_impl(first1)->value(),Node::from_impl(first0)->value())){
> impl_pointer tmp=first1->next();
> impl_type::relink(first0,first1);
> first1=tmp;
> }
> else first0=first0->next();
> }
> impl_type::relink(last0,first1,last1);
>}
>
>
>
>
>
>
>static const std::size_t sequenced_index_sort_max_fill= (std::size_t)std::numeric_limits<std::size_t>::digits+1
>
>
> ;
>
>template<typename Node,typename Compare>
>void sequenced_index_sort(Node* header,Compare comp)
>{
># 127 "/usr/include/boost/multi_index/detail/seq_index_ops.hpp" 3 4
> if(header->next()==header->impl()||
> header->next()->next()==header->impl())return;
>
> typedef typename Node::impl_type impl_type;
> typedef typename Node::impl_pointer impl_pointer;
>
> typedef typename aligned_storage<
> sizeof(impl_type),
> alignment_of<impl_type>::value
> >::type carry_spc_type;
> carry_spc_type carry_spc;
> impl_type& carry=
> *static_cast<impl_type*>(static_cast<void*>(&carry_spc));
> typedef typename aligned_storage<
> sizeof(
> impl_type
> [sequenced_index_sort_max_fill]),
> alignment_of<
> impl_type
> [sequenced_index_sort_max_fill]
> >::value
> >::type counter_spc_type;
> counter_spc_type counter_spc;
> impl_type* counter=
> static_cast<impl_type*>(static_cast<void*>(&counter_spc));
> std::size_t fill=0;
>
> carry.prior()=carry.next()=static_cast<impl_pointer>(&carry);
> counter[0].prior()=counter[0].next()=static_cast<impl_pointer>(&counter[0]);
>
> { try{
> while(header->next()!=header->impl()){
> impl_type::relink(carry.next(),header->next());
> std::size_t i=0;
> while(i<fill&&counter[i].next()!=static_cast<impl_pointer>(&counter[i])){
> sequenced_index_collate<Node>(&carry,&counter[i++],comp);
> }
> impl_type::swap(
> static_cast<impl_pointer>(&carry),
> static_cast<impl_pointer>(&counter[i]));
> if(i==fill){
> ++fill;
> counter[fill].prior()=counter[fill].next()=
> static_cast<impl_pointer>(&counter[fill]);
> }
> }
>
> for(std::size_t i=1;i<fill;++i){
> sequenced_index_collate<Node>(&counter[i],&counter[i-1],comp);
> }
> impl_type::swap(
> header->impl(),static_cast<impl_pointer>(&counter[fill-1]));
> }
> catch(...)
> {
> impl_type::relink(
> header->impl(),carry.next(),static_cast<impl_pointer>(&carry));
> for(std::size_t i=0;i<=fill;++i){
> impl_type::relink(
> header->impl(),counter[i].next(),
> static_cast<impl_pointer>(&counter[i]));
> }
> throw;;
> }
> }
>}
>
>}
>
>}
>
>}
># 34 "/usr/include/boost/multi_index/sequenced_index.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/sequenced_index_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/multi_index/sequenced_index_fwd.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>template<typename SuperMeta,typename TagList>
>class sequenced_index;
>
>template<
> typename SuperMeta1,typename TagList1,
> typename SuperMeta2,typename TagList2
>>
>bool operator==(
> const sequenced_index<SuperMeta1,TagList1>& x,
> const sequenced_index<SuperMeta2,TagList2>& y);
>
>template<
> typename SuperMeta1,typename TagList1,
> typename SuperMeta2,typename TagList2
>>
>bool operator<(
> const sequenced_index<SuperMeta1,TagList1>& x,
> const sequenced_index<SuperMeta2,TagList2>& y);
>
>template<
> typename SuperMeta1,typename TagList1,
> typename SuperMeta2,typename TagList2
>>
>bool operator!=(
> const sequenced_index<SuperMeta1,TagList1>& x,
> const sequenced_index<SuperMeta2,TagList2>& y);
>
>template<
> typename SuperMeta1,typename TagList1,
> typename SuperMeta2,typename TagList2
>>
>bool operator>(
> const sequenced_index<SuperMeta1,TagList1>& x,
> const sequenced_index<SuperMeta2,TagList2>& y);
>
>template<
> typename SuperMeta1,typename TagList1,
> typename SuperMeta2,typename TagList2
>>
>bool operator>=(
> const sequenced_index<SuperMeta1,TagList1>& x,
> const sequenced_index<SuperMeta2,TagList2>& y);
>
>template<
> typename SuperMeta1,typename TagList1,
> typename SuperMeta2,typename TagList2
>>
>bool operator<=(
> const sequenced_index<SuperMeta1,TagList1>& x,
> const sequenced_index<SuperMeta2,TagList2>& y);
>
>template<typename SuperMeta,typename TagList>
>void swap(
> sequenced_index<SuperMeta,TagList>& x,
> sequenced_index<SuperMeta,TagList>& y);
>
>}
>
>
>
>template <typename TagList=tag<> >
>struct sequenced;
>
>}
>
>}
># 35 "/usr/include/boost/multi_index/sequenced_index.hpp" 2 3 4
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 38 "/usr/include/boost/multi_index/sequenced_index.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/bind.hpp" 1 3 4
># 22 "/usr/include/boost/bind.hpp" 3 4
># 1 "/usr/include/boost/bind/bind.hpp" 1 3 4
># 26 "/usr/include/boost/bind/bind.hpp" 3 4
># 1 "/usr/include/boost/mem_fn.hpp" 1 3 4
># 22 "/usr/include/boost/mem_fn.hpp" 3 4
># 1 "/usr/include/boost/bind/mem_fn.hpp" 1 3 4
># 25 "/usr/include/boost/bind/mem_fn.hpp" 3 4
># 1 "/usr/include/boost/get_pointer.hpp" 1 3 4
># 16 "/usr/include/boost/get_pointer.hpp" 3 4
>namespace boost {
>
>
>
>template<class T> T * get_pointer(T * p)
>{
> return p;
>}
>
>
>
>template<class T> T * get_pointer(std::auto_ptr<T> const& p)
>{
> return p.get();
>}
>
>
>
>template<class T> T * get_pointer( std::unique_ptr<T> const& p )
>{
> return p.get();
>}
>
>template<class T> T * get_pointer( std::shared_ptr<T> const& p )
>{
> return p.get();
>}
>
>
>
>}
># 26 "/usr/include/boost/bind/mem_fn.hpp" 2 3 4
>
>
>namespace boost
>{
># 207 "/usr/include/boost/bind/mem_fn.hpp" 3 4
>namespace _mfi
>{
>
>
>
>
>
>
># 1 "/usr/include/boost/bind/mem_fn_template.hpp" 1 3 4
># 21 "/usr/include/boost/bind/mem_fn_template.hpp" 3 4
>template<class R, class T > class mf0
>{
>public:
>
> typedef R result_type;
> typedef T * argument_type;
>
>private:
>
> typedef R ( T::*F) ();
> F f_;
>
> template<class U> R call(U & u, T const *) const
> {
> return (u.*f_)();
> }
>
> template<class U> R call(U & u, void const *) const
> {
> return (get_pointer(u)->*f_)();
> }
>
>public:
>
> explicit mf0(F f): f_(f) {}
>
> R operator()(T * p) const
> {
> return (p->*f_)();
> }
>
> template<class U> R operator()(U & u) const
> {
> U const * p = 0;
> return call(u, p);
> }
>
>
>
> template<class U> R operator()(U const & u) const
> {
> U const * p = 0;
> return call(u, p);
> }
>
>
>
> R operator()(T & t) const
> {
> return (t.*f_)();
> }
>
> bool operator==(mf0 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(mf0 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T > class cmf0
>{
>public:
>
> typedef R result_type;
> typedef T const * argument_type;
>
>private:
>
> typedef R ( T::*F) () const;
> F f_;
>
> template<class U> R call(U & u, T const *) const
> {
> return (u.*f_)();
> }
>
> template<class U> R call(U & u, void const *) const
> {
> return (get_pointer(u)->*f_)();
> }
>
>public:
>
> explicit cmf0(F f): f_(f) {}
>
> template<class U> R operator()(U const & u) const
> {
> U const * p = 0;
> return call(u, p);
> }
>
> R operator()(T const & t) const
> {
> return (t.*f_)();
> }
>
> bool operator==(cmf0 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(cmf0 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1 > class mf1
>{
>public:
>
> typedef R result_type;
> typedef T * first_argument_type;
> typedef A1 second_argument_type;
>
>private:
>
> typedef R ( T::*F) (A1);
> F f_;
>
> template<class U, class B1> R call(U & u, T const *, B1 & b1) const
> {
> return (u.*f_)(b1);
> }
>
> template<class U, class B1> R call(U & u, void const *, B1 & b1) const
> {
> return (get_pointer(u)->*f_)(b1);
> }
>
>public:
>
> explicit mf1(F f): f_(f) {}
>
> R operator()(T * p, A1 a1) const
> {
> return (p->*f_)(a1);
> }
>
> template<class U> R operator()(U & u, A1 a1) const
> {
> U const * p = 0;
> return call(u, p, a1);
> }
>
>
>
> template<class U> R operator()(U const & u, A1 a1) const
> {
> U const * p = 0;
> return call(u, p, a1);
> }
>
>
>
> R operator()(T & t, A1 a1) const
> {
> return (t.*f_)(a1);
> }
>
> bool operator==(mf1 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(mf1 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1 > class cmf1
>{
>public:
>
> typedef R result_type;
> typedef T const * first_argument_type;
> typedef A1 second_argument_type;
>
>private:
>
> typedef R ( T::*F) (A1) const;
> F f_;
>
> template<class U, class B1> R call(U & u, T const *, B1 & b1) const
> {
> return (u.*f_)(b1);
> }
>
> template<class U, class B1> R call(U & u, void const *, B1 & b1) const
> {
> return (get_pointer(u)->*f_)(b1);
> }
>
>public:
>
> explicit cmf1(F f): f_(f) {}
>
> template<class U> R operator()(U const & u, A1 a1) const
> {
> U const * p = 0;
> return call(u, p, a1);
> }
>
> R operator()(T const & t, A1 a1) const
> {
> return (t.*f_)(a1);
> }
>
> bool operator==(cmf1 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(cmf1 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1, class A2 > class mf2
>{
>public:
>
> typedef R result_type;
>
>private:
>
> typedef R ( T::*F) (A1, A2);
> F f_;
>
> template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
> {
> return (u.*f_)(b1, b2);
> }
>
> template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
> {
> return (get_pointer(u)->*f_)(b1, b2);
> }
>
>public:
>
> explicit mf2(F f): f_(f) {}
>
> R operator()(T * p, A1 a1, A2 a2) const
> {
> return (p->*f_)(a1, a2);
> }
>
> template<class U> R operator()(U & u, A1 a1, A2 a2) const
> {
> U const * p = 0;
> return call(u, p, a1, a2);
> }
>
>
>
> template<class U> R operator()(U const & u, A1 a1, A2 a2) const
> {
> U const * p = 0;
> return call(u, p, a1, a2);
> }
>
>
>
> R operator()(T & t, A1 a1, A2 a2) const
> {
> return (t.*f_)(a1, a2);
> }
>
> bool operator==(mf2 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(mf2 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1, class A2 > class cmf2
>{
>public:
>
> typedef R result_type;
>
>private:
>
> typedef R ( T::*F) (A1, A2) const;
> F f_;
>
> template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
> {
> return (u.*f_)(b1, b2);
> }
>
> template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
> {
> return (get_pointer(u)->*f_)(b1, b2);
> }
>
>public:
>
> explicit cmf2(F f): f_(f) {}
>
> template<class U> R operator()(U const & u, A1 a1, A2 a2) const
> {
> U const * p = 0;
> return call(u, p, a1, a2);
> }
>
> R operator()(T const & t, A1 a1, A2 a2) const
> {
> return (t.*f_)(a1, a2);
> }
>
> bool operator==(cmf2 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(cmf2 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1, class A2, class A3 > class mf3
>{
>public:
>
> typedef R result_type;
>
>private:
>
> typedef R ( T::*F) (A1, A2, A3);
> F f_;
>
> template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
> {
> return (u.*f_)(b1, b2, b3);
> }
>
> template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
> {
> return (get_pointer(u)->*f_)(b1, b2, b3);
> }
>
>public:
>
> explicit mf3(F f): f_(f) {}
>
> R operator()(T * p, A1 a1, A2 a2, A3 a3) const
> {
> return (p->*f_)(a1, a2, a3);
> }
>
> template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3);
> }
>
>
>
> template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3);
> }
>
>
>
> R operator()(T & t, A1 a1, A2 a2, A3 a3) const
> {
> return (t.*f_)(a1, a2, a3);
> }
>
> bool operator==(mf3 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(mf3 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1, class A2, class A3 > class cmf3
>{
>public:
>
> typedef R result_type;
>
>private:
>
> typedef R ( T::*F) (A1, A2, A3) const;
> F f_;
>
> template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
> {
> return (u.*f_)(b1, b2, b3);
> }
>
> template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
> {
> return (get_pointer(u)->*f_)(b1, b2, b3);
> }
>
>public:
>
> explicit cmf3(F f): f_(f) {}
>
> template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3);
> }
>
> R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
> {
> return (t.*f_)(a1, a2, a3);
> }
>
> bool operator==(cmf3 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(cmf3 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1, class A2, class A3, class A4 > class mf4
>{
>public:
>
> typedef R result_type;
>
>private:
>
> typedef R ( T::*F) (A1, A2, A3, A4);
> F f_;
>
> template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
> {
> return (u.*f_)(b1, b2, b3, b4);
> }
>
> template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
> {
> return (get_pointer(u)->*f_)(b1, b2, b3, b4);
> }
>
>public:
>
> explicit mf4(F f): f_(f) {}
>
> R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
> {
> return (p->*f_)(a1, a2, a3, a4);
> }
>
> template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3, a4);
> }
>
>
>
> template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3, a4);
> }
>
>
>
> R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
> {
> return (t.*f_)(a1, a2, a3, a4);
> }
>
> bool operator==(mf4 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(mf4 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1, class A2, class A3, class A4 > class cmf4
>{
>public:
>
> typedef R result_type;
>
>private:
>
> typedef R ( T::*F) (A1, A2, A3, A4) const;
> F f_;
>
> template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
> {
> return (u.*f_)(b1, b2, b3, b4);
> }
>
> template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
> {
> return (get_pointer(u)->*f_)(b1, b2, b3, b4);
> }
>
>public:
>
> explicit cmf4(F f): f_(f) {}
>
> template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3, a4);
> }
>
> R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
> {
> return (t.*f_)(a1, a2, a3, a4);
> }
>
> bool operator==(cmf4 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(cmf4 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5 > class mf5
>{
>public:
>
> typedef R result_type;
>
>private:
>
> typedef R ( T::*F) (A1, A2, A3, A4, A5);
> F f_;
>
> template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
> {
> return (u.*f_)(b1, b2, b3, b4, b5);
> }
>
> template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
> {
> return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
> }
>
>public:
>
> explicit mf5(F f): f_(f) {}
>
> R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
> {
> return (p->*f_)(a1, a2, a3, a4, a5);
> }
>
> template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3, a4, a5);
> }
>
>
>
> template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3, a4, a5);
> }
>
>
>
> R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
> {
> return (t.*f_)(a1, a2, a3, a4, a5);
> }
>
> bool operator==(mf5 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(mf5 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5 > class cmf5
>{
>public:
>
> typedef R result_type;
>
>private:
>
> typedef R ( T::*F) (A1, A2, A3, A4, A5) const;
> F f_;
>
> template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
> {
> return (u.*f_)(b1, b2, b3, b4, b5);
> }
>
> template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
> {
> return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
> }
>
>public:
>
> explicit cmf5(F f): f_(f) {}
>
> template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3, a4, a5);
> }
>
> R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
> {
> return (t.*f_)(a1, a2, a3, a4, a5);
> }
>
> bool operator==(cmf5 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(cmf5 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 > class mf6
>{
>public:
>
> typedef R result_type;
>
>private:
>
> typedef R ( T::*F) (A1, A2, A3, A4, A5, A6);
> F f_;
>
> template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
> {
> return (u.*f_)(b1, b2, b3, b4, b5, b6);
> }
>
> template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
> {
> return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
> }
>
>public:
>
> explicit mf6(F f): f_(f) {}
>
> R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
> {
> return (p->*f_)(a1, a2, a3, a4, a5, a6);
> }
>
> template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3, a4, a5, a6);
> }
>
>
>
> template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3, a4, a5, a6);
> }
>
>
>
> R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
> {
> return (t.*f_)(a1, a2, a3, a4, a5, a6);
> }
>
> bool operator==(mf6 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(mf6 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 > class cmf6
>{
>public:
>
> typedef R result_type;
>
>private:
>
> typedef R ( T::*F) (A1, A2, A3, A4, A5, A6) const;
> F f_;
>
> template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
> {
> return (u.*f_)(b1, b2, b3, b4, b5, b6);
> }
>
> template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
> {
> return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
> }
>
>public:
>
> explicit cmf6(F f): f_(f) {}
>
> template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3, a4, a5, a6);
> }
>
> R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
> {
> return (t.*f_)(a1, a2, a3, a4, a5, a6);
> }
>
> bool operator==(cmf6 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(cmf6 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class mf7
>{
>public:
>
> typedef R result_type;
>
>private:
>
> typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7);
> F f_;
>
> template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
> {
> return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
> }
>
> template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
> {
> return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
> }
>
>public:
>
> explicit mf7(F f): f_(f) {}
>
> R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
> {
> return (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
> }
>
> template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3, a4, a5, a6, a7);
> }
>
>
>
> template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3, a4, a5, a6, a7);
> }
>
>
>
> R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
> {
> return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
> }
>
> bool operator==(mf7 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(mf7 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class cmf7
>{
>public:
>
> typedef R result_type;
>
>private:
>
> typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
> F f_;
>
> template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
> {
> return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
> }
>
> template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
> {
> return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
> }
>
>public:
>
> explicit cmf7(F f): f_(f) {}
>
> template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3, a4, a5, a6, a7);
> }
>
> R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
> {
> return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
> }
>
> bool operator==(cmf7 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(cmf7 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class mf8
>{
>public:
>
> typedef R result_type;
>
>private:
>
> typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
> F f_;
>
> template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
> {
> return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
> }
>
> template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
> {
> return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
> }
>
>public:
>
> explicit mf8(F f): f_(f) {}
>
> R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
> {
> return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
> }
>
> template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
> }
>
>
>
> template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
> }
>
>
>
> R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
> {
> return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
> }
>
> bool operator==(mf8 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(mf8 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class cmf8
>{
>public:
>
> typedef R result_type;
>
>private:
>
> typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
> F f_;
>
> template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
> {
> return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
> }
>
> template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
> {
> return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
> }
>
>public:
>
> explicit cmf8(F f): f_(f) {}
>
> R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
> {
> return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
> }
>
> template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
> {
> U const * p = 0;
> return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
> }
>
> R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
> {
> return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
> }
>
> bool operator==(cmf8 const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(cmf8 const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
># 216 "/usr/include/boost/bind/mem_fn.hpp" 2 3 4
># 258 "/usr/include/boost/bind/mem_fn.hpp" 3 4
>}
># 268 "/usr/include/boost/bind/mem_fn.hpp" 3 4
># 1 "/usr/include/boost/bind/mem_fn_cc.hpp" 1 3 4
># 15 "/usr/include/boost/bind/mem_fn_cc.hpp" 3 4
>template<class R, class T> _mfi::mf0<R, T> mem_fn(R ( T::*f) ())
>{
> return _mfi::mf0<R, T>(f);
>}
>
>template<class R, class T> _mfi::cmf0<R, T> mem_fn(R ( T::*f) () const)
>{
> return _mfi::cmf0<R, T>(f);
>}
>
>template<class R, class T, class A1> _mfi::mf1<R, T, A1> mem_fn(R ( T::*f) (A1))
>{
> return _mfi::mf1<R, T, A1>(f);
>}
>
>template<class R, class T, class A1> _mfi::cmf1<R, T, A1> mem_fn(R ( T::*f) (A1) const)
>{
> return _mfi::cmf1<R, T, A1>(f);
>}
>
>template<class R, class T, class A1, class A2> _mfi::mf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2))
>{
> return _mfi::mf2<R, T, A1, A2>(f);
>}
>
>template<class R, class T, class A1, class A2> _mfi::cmf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2) const)
>{
> return _mfi::cmf2<R, T, A1, A2>(f);
>}
>
>template<class R, class T, class A1, class A2, class A3> _mfi::mf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3))
>{
> return _mfi::mf3<R, T, A1, A2, A3>(f);
>}
>
>template<class R, class T, class A1, class A2, class A3> _mfi::cmf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3) const)
>{
> return _mfi::cmf3<R, T, A1, A2, A3>(f);
>}
>
>template<class R, class T, class A1, class A2, class A3, class A4> _mfi::mf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4))
>{
> return _mfi::mf4<R, T, A1, A2, A3, A4>(f);
>}
>
>template<class R, class T, class A1, class A2, class A3, class A4> _mfi::cmf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4) const)
>{
> return _mfi::cmf4<R, T, A1, A2, A3, A4>(f);
>}
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::mf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5))
>{
> return _mfi::mf5<R, T, A1, A2, A3, A4, A5>(f);
>}
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::cmf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5) const)
>{
> return _mfi::cmf5<R, T, A1, A2, A3, A4, A5>(f);
>}
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6))
>{
> return _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6>(f);
>}
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6) const)
>{
> return _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6>(f);
>}
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7))
>{
> return _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
>}
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
>{
> return _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
>}
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
>{
> return _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
>}
>
>template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
>{
> return _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
>}
># 269 "/usr/include/boost/bind/mem_fn.hpp" 2 3 4
># 311 "/usr/include/boost/bind/mem_fn.hpp" 3 4
>namespace _mfi
>{
>
>template<class R, class T> class dm
>{
>public:
>
> typedef R const & result_type;
> typedef T const * argument_type;
>
>private:
>
> typedef R (T::*F);
> F f_;
>
> template<class U> R const & call(U & u, T const *) const
> {
> return (u.*f_);
> }
>
> template<class U> R const & call(U & u, void const *) const
> {
> return (get_pointer(u)->*f_);
> }
>
>public:
>
> explicit dm(F f): f_(f) {}
>
> R & operator()(T * p) const
> {
> return (p->*f_);
> }
>
> R const & operator()(T const * p) const
> {
> return (p->*f_);
> }
>
> template<class U> R const & operator()(U const & u) const
> {
> return call(u, &u);
> }
>
>
>
> R & operator()(T & t) const
> {
> return (t.*f_);
> }
>
> R const & operator()(T const & t) const
> {
> return (t.*f_);
> }
>
>
>
> bool operator==(dm const & rhs) const
> {
> return f_ == rhs.f_;
> }
>
> bool operator!=(dm const & rhs) const
> {
> return f_ != rhs.f_;
> }
>};
>
>}
>
>template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f)
>{
> return _mfi::dm<R, T>(f);
>}
>
>}
># 23 "/usr/include/boost/mem_fn.hpp" 2 3 4
># 27 "/usr/include/boost/bind/bind.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/visit_each.hpp" 1 3 4
># 15 "/usr/include/boost/visit_each.hpp" 3 4
>namespace boost {
> template<typename Visitor, typename T>
> inline void visit_each(Visitor& visitor, const T& t, long)
> {
> visitor(t);
> }
>
> template<typename Visitor, typename T>
> inline void visit_each(Visitor& visitor, const T& t)
> {
> visit_each(visitor, t, 0);
> }
>}
># 32 "/usr/include/boost/bind/bind.hpp" 2 3 4
># 41 "/usr/include/boost/bind/bind.hpp" 3 4
># 1 "/usr/include/boost/bind/storage.hpp" 1 3 4
># 32 "/usr/include/boost/bind/storage.hpp" 3 4
>namespace boost
>{
>
>namespace _bi
>{
>
>
>
>template<class A1> struct storage1
>{
> explicit storage1( A1 a1 ): a1_( a1 ) {}
>
> template<class V> void accept(V & v) const
> {
> visit_each(v, a1_, 0);
> }
>
> A1 a1_;
>};
>
>
>
>template<int I> struct storage1< boost::arg >
>{
> explicit storage1( boost::arg ) {}
>
> template<class V> void accept(V &) const { }
>
> static boost::arg a1_() { return boost::arg(); }
>};
>
>template<int I> struct storage1< boost::arg (*) () >
>{
> explicit storage1( boost::arg (*) () ) {}
>
> template<class V> void accept(V &) const { }
>
> static boost::arg a1_() { return boost::arg(); }
>};
>
>
>
>
>
>template<class A1, class A2> struct storage2: public storage1<A1>
>{
> typedef storage1<A1> inherited;
>
> storage2( A1 a1, A2 a2 ): storage1<A1>( a1 ), a2_( a2 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> visit_each(v, a2_, 0);
> }
>
> A2 a2_;
>};
>
>
>
>template<class A1, int I> struct storage2< A1, boost::arg >: public storage1<A1>
>{
> typedef storage1<A1> inherited;
>
> storage2( A1 a1, boost::arg ): storage1<A1>( a1 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a2_() { return boost::arg(); }
>};
>
>template<class A1, int I> struct storage2< A1, boost::arg (*) () >: public storage1<A1>
>{
> typedef storage1<A1> inherited;
>
> storage2( A1 a1, boost::arg (*) () ): storage1<A1>( a1 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a2_() { return boost::arg(); }
>};
>
>
>
>
>
>template<class A1, class A2, class A3> struct storage3: public storage2< A1, A2 >
>{
> typedef storage2<A1, A2> inherited;
>
> storage3( A1 a1, A2 a2, A3 a3 ): storage2<A1, A2>( a1, a2 ), a3_( a3 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> visit_each(v, a3_, 0);
> }
>
> A3 a3_;
>};
>
>
>
>template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg >: public storage2< A1, A2 >
>{
> typedef storage2<A1, A2> inherited;
>
> storage3( A1 a1, A2 a2, boost::arg ): storage2<A1, A2>( a1, a2 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a3_() { return boost::arg(); }
>};
>
>template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg (*) () >: public storage2< A1, A2 >
>{
> typedef storage2<A1, A2> inherited;
>
> storage3( A1 a1, A2 a2, boost::arg (*) () ): storage2<A1, A2>( a1, a2 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a3_() { return boost::arg(); }
>};
>
>
>
>
>
>template<class A1, class A2, class A3, class A4> struct storage4: public storage3< A1, A2, A3 >
>{
> typedef storage3<A1, A2, A3> inherited;
>
> storage4( A1 a1, A2 a2, A3 a3, A4 a4 ): storage3<A1, A2, A3>( a1, a2, a3 ), a4_( a4 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> visit_each(v, a4_, 0);
> }
>
> A4 a4_;
>};
>
>
>
>template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg >: public storage3< A1, A2, A3 >
>{
> typedef storage3<A1, A2, A3> inherited;
>
> storage4( A1 a1, A2 a2, A3 a3, boost::arg ): storage3<A1, A2, A3>( a1, a2, a3 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a4_() { return boost::arg(); }
>};
>
>template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg (*) () >: public storage3< A1, A2, A3 >
>{
> typedef storage3<A1, A2, A3> inherited;
>
> storage4( A1 a1, A2 a2, A3 a3, boost::arg (*) () ): storage3<A1, A2, A3>( a1, a2, a3 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a4_() { return boost::arg(); }
>};
>
>
>
>
>
>template<class A1, class A2, class A3, class A4, class A5> struct storage5: public storage4< A1, A2, A3, A4 >
>{
> typedef storage4<A1, A2, A3, A4> inherited;
>
> storage5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ), a5_( a5 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> visit_each(v, a5_, 0);
> }
>
> A5 a5_;
>};
>
>
>
>template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg >: public storage4< A1, A2, A3, A4 >
>{
> typedef storage4<A1, A2, A3, A4> inherited;
>
> storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a5_() { return boost::arg(); }
>};
>
>template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg (*) () >: public storage4< A1, A2, A3, A4 >
>{
> typedef storage4<A1, A2, A3, A4> inherited;
>
> storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg (*) () ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a5_() { return boost::arg(); }
>};
>
>
>
>
>
>template<class A1, class A2, class A3, class A4, class A5, class A6> struct storage6: public storage5< A1, A2, A3, A4, A5 >
>{
> typedef storage5<A1, A2, A3, A4, A5> inherited;
>
> storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ), a6_( a6 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> visit_each(v, a6_, 0);
> }
>
> A6 a6_;
>};
>
>
>
>template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg >: public storage5< A1, A2, A3, A4, A5 >
>{
> typedef storage5<A1, A2, A3, A4, A5> inherited;
>
> storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a6_() { return boost::arg(); }
>};
>
>template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg (*) () >: public storage5< A1, A2, A3, A4, A5 >
>{
> typedef storage5<A1, A2, A3, A4, A5> inherited;
>
> storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg (*) () ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a6_() { return boost::arg(); }
>};
>
>
>
>
>
>template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct storage7: public storage6< A1, A2, A3, A4, A5, A6 >
>{
> typedef storage6<A1, A2, A3, A4, A5, A6> inherited;
>
> storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ), a7_( a7 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> visit_each(v, a7_, 0);
> }
>
> A7 a7_;
>};
>
>
>
>template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg >: public storage6< A1, A2, A3, A4, A5, A6 >
>{
> typedef storage6<A1, A2, A3, A4, A5, A6> inherited;
>
> storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a7_() { return boost::arg(); }
>};
>
>template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg (*) () >: public storage6< A1, A2, A3, A4, A5, A6 >
>{
> typedef storage6<A1, A2, A3, A4, A5, A6> inherited;
>
> storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg (*) () ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a7_() { return boost::arg(); }
>};
>
>
>
>
>
>template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct storage8: public storage7< A1, A2, A3, A4, A5, A6, A7 >
>{
> typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;
>
> storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ), a8_( a8 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> visit_each(v, a8_, 0);
> }
>
> A8 a8_;
>};
>
>
>
>template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
>{
> typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;
>
> storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a8_() { return boost::arg(); }
>};
>
>template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg (*) () >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
>{
> typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;
>
> storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg (*) () ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a8_() { return boost::arg(); }
>};
>
>
>
>
>
>template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct storage9: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
>{
> typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;
>
> storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ), a9_( a9 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> visit_each(v, a9_, 0);
> }
>
> A9 a9_;
>};
>
>
>
>template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
>{
> typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;
>
> storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a9_() { return boost::arg(); }
>};
>
>template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg (*) () >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
>{
> typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;
>
> storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg (*) () ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
>
> template<class V> void accept(V & v) const
> {
> inherited::accept(v);
> }
>
> static boost::arg a9_() { return boost::arg(); }
>};
>
>
>
>}
>
>}
># 42 "/usr/include/boost/bind/bind.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost
>{
>
>template<class T> class weak_ptr;
>
>namespace _bi
>{
>
>
>
>template<class R, class F> struct result_traits
>{
> typedef R type;
>};
>
>
>
>struct unspecified {};
>
>template<class F> struct result_traits<unspecified, F>
>{
> typedef typename F::result_type type;
>};
>
>template<class F> struct result_traits< unspecified, reference_wrapper<F> >
>{
> typedef typename F::result_type type;
>};
>
>
>
>
>
>template<class T> bool ref_compare( T const & a, T const & b, long )
>{
> return a == b;
>}
>
>template<int I> bool ref_compare( arg const &, arg const &, int )
>{
> return true;
>}
>
>template<int I> bool ref_compare( arg (*) (), arg (*) (), int )
>{
> return true;
>}
>
>template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
>{
> return a.get_pointer() == b.get_pointer();
>}
>
>
>
>template<class R, class F, class L> class bind_t;
>
>template<class R, class F, class L> bool ref_compare( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b, int )
>{
> return a.compare( b );
>}
>
>
>
>template<class T> class value
>{
>public:
>
> value(T const & t): t_(t) {}
>
> T & get() { return t_; }
> T const & get() const { return t_; }
>
> bool operator==(value const & rhs) const
> {
> return t_ == rhs.t_;
> }
>
>private:
>
> T t_;
>};
>
>
>
>template<class T> bool ref_compare( value< weak_ptr<T> > const & a, value< weak_ptr<T> > const & b, int )
>{
> return !(a.get() < b.get()) && !(b.get() < a.get());
>}
>
>
>
>template<class T> class type {};
>
>
>
>template<class F> struct unwrapper
>{
> static inline F & unwrap( F & f, long )
> {
> return f;
> }
>
> template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )
> {
> return rf.get();
> }
>
> template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
> {
> return _mfi::dm<R, T>( pm );
> }
>};
>
>
>
>class list0
>{
>public:
>
> list0() {}
>
> template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
>
> template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
>
> template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
>
> template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
> {
> return unwrapper<F>::unwrap(f, 0)();
> }
>
> template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
> {
> return unwrapper<F const>::unwrap(f, 0)();
> }
>
> template<class F, class A> void operator()(type<void>, F & f, A &, int)
> {
> unwrapper<F>::unwrap(f, 0)();
> }
>
> template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
> {
> unwrapper<F const>::unwrap(f, 0)();
> }
>
> template<class V> void accept(V &) const
> {
> }
>
> bool operator==(list0 const &) const
> {
> return true;
> }
>};
># 217 "/usr/include/boost/bind/bind.hpp" 3 4
>template< class A1 > class list1: private storage1< A1 >
>{
>private:
>
> typedef storage1< A1 > base_type;
>
>public:
>
> explicit list1( A1 a1 ): base_type( a1 ) {}
>
> A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
>
> A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
>
> template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
>
> template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
>
> template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
>
> template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
> {
> return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
> }
>
> template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
> {
> return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
> }
>
> template<class F, class A> void operator()(type<void>, F & f, A & a, int)
> {
> unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
> }
>
> template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
> {
> unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
> }
>
> template<class V> void accept(V & v) const
> {
> base_type::accept(v);
> }
>
> bool operator==(list1 const & rhs) const
> {
> return ref_compare(base_type::a1_, rhs.a1_, 0);
> }
>};
>
>struct logical_and;
>struct logical_or;
>
>template< class A1, class A2 > class list2: private storage2< A1, A2 >
>{
>private:
>
> typedef storage2< A1, A2 > base_type;
>
>public:
>
> list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}
>
> A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
>
> A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
>
> template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
>
> template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
>
> template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
>
> template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
> {
> return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
> }
>
> template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
> {
> return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
> }
>
> template<class F, class A> void operator()(type<void>, F & f, A & a, int)
> {
> unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
> }
>
> template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
> {
> unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
> }
>
> template<class A> bool operator()( type<bool>, logical_and & , A & a, int )
> {
> return a[ base_type::a1_ ] && a[ base_type::a2_ ];
> }
>
> template<class A> bool operator()( type<bool>, logical_and const & , A & a, int ) const
> {
> return a[ base_type::a1_ ] && a[ base_type::a2_ ];
> }
>
> template<class A> bool operator()( type<bool>, logical_or & , A & a, int )
> {
> return a[ base_type::a1_ ] || a[ base_type::a2_ ];
> }
>
> template<class A> bool operator()( type<bool>, logical_or const & , A & a, int ) const
> {
> return a[ base_type::a1_ ] || a[ base_type::a2_ ];
> }
>
> template<class V> void accept(V & v) const
> {
> base_type::accept(v);
> }
>
> bool operator==(list2 const & rhs) const
> {
> return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0);
> }
>};
>
>template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >
>{
>private:
>
> typedef storage3< A1, A2, A3 > base_type;
>
>public:
>
> list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {}
>
> A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
> A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
>
> A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
> A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
>
> template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
>
> template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
>
> template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
>
> template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
> {
> return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
> }
>
> template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
> {
> return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
> }
>
> template<class F, class A> void operator()(type<void>, F & f, A & a, int)
> {
> unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
> }
>
> template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
> {
> unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
> }
>
> template<class V> void accept(V & v) const
> {
> base_type::accept(v);
> }
>
> bool operator==(list3 const & rhs) const
> {
> return
>
> ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
> ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
> ref_compare( base_type::a3_, rhs.a3_, 0 );
> }
>};
>
>template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 >
>{
>private:
>
> typedef storage4< A1, A2, A3, A4 > base_type;
>
>public:
>
> list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {}
>
> A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
> A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
> A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
>
> A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
> A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
> A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
>
> template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
>
> template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
>
> template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
>
> template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
> {
> return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
> }
>
> template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
> {
> return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
> }
>
> template<class F, class A> void operator()(type<void>, F & f, A & a, int)
> {
> unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
> }
>
> template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
> {
> unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
> }
>
> template<class V> void accept(V & v) const
> {
> base_type::accept(v);
> }
>
> bool operator==(list4 const & rhs) const
> {
> return
>
> ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
> ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
> ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
> ref_compare( base_type::a4_, rhs.a4_, 0 );
> }
>};
>
>template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 >
>{
>private:
>
> typedef storage5< A1, A2, A3, A4, A5 > base_type;
>
>public:
>
> list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {}
>
> A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
> A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
> A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
> A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
>
> A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
> A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
> A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
> A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
>
> template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
>
> template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
>
> template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
>
> template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
> {
> return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
> }
>
> template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
> {
> return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
> }
>
> template<class F, class A> void operator()(type<void>, F & f, A & a, int)
> {
> unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
> }
>
> template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
> {
> unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
> }
>
> template<class V> void accept(V & v) const
> {
> base_type::accept(v);
> }
>
> bool operator==(list5 const & rhs) const
> {
> return
>
> ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
> ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
> ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
> ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
> ref_compare( base_type::a5_, rhs.a5_, 0 );
> }
>};
>
>template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 >
>{
>private:
>
> typedef storage6< A1, A2, A3, A4, A5, A6 > base_type;
>
>public:
>
> list6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): base_type( a1, a2, a3, a4, a5, a6 ) {}
>
> A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
> A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
> A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
> A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
> A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
>
> A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
> A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
> A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
> A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
> A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
>
> template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
>
> template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
>
> template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
>
> template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
> {
> return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
> }
>
> template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
> {
> return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
> }
>
> template<class F, class A> void operator()(type<void>, F & f, A & a, int)
> {
> unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
> }
>
> template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
> {
> unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
> }
>
> template<class V> void accept(V & v) const
> {
> base_type::accept(v);
> }
>
> bool operator==(list6 const & rhs) const
> {
> return
>
> ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
> ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
> ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
> ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
> ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
> ref_compare( base_type::a6_, rhs.a6_, 0 );
> }
>};
>
>template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> class list7: private storage7< A1, A2, A3, A4, A5, A6, A7 >
>{
>private:
>
> typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type;
>
>public:
>
> list7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): base_type( a1, a2, a3, a4, a5, a6, a7 ) {}
>
> A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
> A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
> A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
> A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
> A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
> A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
>
> A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
> A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
> A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
> A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
> A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
> A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
>
> template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
>
> template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
>
> template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
>
> template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
> {
> return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
> }
>
> template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
> {
> return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
> }
>
> template<class F, class A> void operator()(type<void>, F & f, A & a, int)
> {
> unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
> }
>
> template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
> {
> unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
> }
>
> template<class V> void accept(V & v) const
> {
> base_type::accept(v);
> }
>
> bool operator==(list7 const & rhs) const
> {
> return
>
> ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
> ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
> ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
> ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
> ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
> ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
> ref_compare( base_type::a7_, rhs.a7_, 0 );
> }
>};
>
>template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class list8: private storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
>{
>private:
>
> typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type;
>
>public:
>
> list8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
>
> A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
> A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
> A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
> A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
> A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
> A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
> A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
>
> A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
> A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
> A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
> A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
> A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
> A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
> A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
>
> template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
>
> template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
>
> template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
>
> template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
> {
> return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
> }
>
> template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
> {
> return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
> }
>
> template<class F, class A> void operator()(type<void>, F & f, A & a, int)
> {
> unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
> }
>
> template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
> {
> unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
> }
>
> template<class V> void accept(V & v) const
> {
> base_type::accept(v);
> }
>
> bool operator==(list8 const & rhs) const
> {
> return
>
> ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
> ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
> ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
> ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
> ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
> ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
> ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
> ref_compare( base_type::a8_, rhs.a8_, 0 );
> }
>};
>
>template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> class list9: private storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 >
>{
>private:
>
> typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type;
>
>public:
>
> list9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8, a9 ) {}
>
> A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
> A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
> A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
> A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
> A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
> A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
> A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
> A9 operator[] (boost::arg<9>) const { return base_type::a9_; }
>
> A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
> A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
> A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
> A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
> A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
> A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
> A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
> A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
> A9 operator[] (boost::arg<9> (*) ()) const { return base_type::a9_; }
>
> template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
>
> template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
>
> template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
>
> template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
>
> template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
> {
> return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
> }
>
> template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
> {
> return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
> }
>
> template<class F, class A> void operator()(type<void>, F & f, A & a, int)
> {
> unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
> }
>
> template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
> {
> unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
> }
>
> template<class V> void accept(V & v) const
> {
> base_type::accept(v);
> }
>
> bool operator==(list9 const & rhs) const
> {
> return
>
> ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
> ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
> ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
> ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
> ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
> ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
> ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
> ref_compare( base_type::a8_, rhs.a8_, 0 ) &&
> ref_compare( base_type::a9_, rhs.a9_, 0 );
> }
>};
># 864 "/usr/include/boost/bind/bind.hpp" 3 4
>template<class R, class F, class L> class bind_t
>{
>public:
>
> typedef bind_t this_type;
>
> bind_t(F f, L const & l): f_(f), l_(l) {}
>
>
># 1 "/usr/include/boost/bind/bind_template.hpp" 1 3 4
># 15 "/usr/include/boost/bind/bind_template.hpp" 3 4
> typedef typename result_traits<R, F>::type result_type;
>
> result_type operator()()
> {
> list0 a;
> return l_(type<result_type>(), f_, a, 0);
> }
>
> result_type operator()() const
> {
> list0 a;
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1> result_type operator()(A1 & a1)
> {
> list1<A1 &> a(a1);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1> result_type operator()(A1 & a1) const
> {
> list1<A1 &> a(a1);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
>
> template<class A1> result_type operator()(A1 const & a1)
> {
> list1<A1 const &> a(a1);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1> result_type operator()(A1 const & a1) const
> {
> list1<A1 const &> a(a1);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
> template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
> {
> list2<A1 &, A2 &> a(a1, a2);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
> {
> list2<A1 &, A2 &> a(a1, a2);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
>
> template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
> {
> list2<A1 const &, A2 &> a(a1, a2);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
> {
> list2<A1 const &, A2 &> a(a1, a2);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
> template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
> {
> list2<A1 &, A2 const &> a(a1, a2);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
> {
> list2<A1 &, A2 const &> a(a1, a2);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
> template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
> {
> list2<A1 const &, A2 const &> a(a1, a2);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
> {
> list2<A1 const &, A2 const &> a(a1, a2);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
> template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
> {
> list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
> {
> list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
>
> template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
> {
> list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
> {
> list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
> template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
> {
> list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
> {
> list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
>
> template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
> {
> list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
> {
> list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
> template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
> {
> list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
> {
> list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
>
> template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
> {
> list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
> {
> list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
> template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
> {
> list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
> {
> list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
>
> template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
> {
> list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
> {
> list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
> template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
> {
> list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
> {
> list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
>
> template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
> {
> list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
> {
> list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
> template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
> {
> list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
> {
> list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
>
> template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
> {
> list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8) const
> {
> list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
> template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
> {
> list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
> {
> list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
>
> template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
> {
> list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const
> {
> list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
> return l_(type<result_type>(), f_, a, 0);
> }
>
>
>
> template<class A> result_type eval(A & a)
> {
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class A> result_type eval(A & a) const
> {
> return l_(type<result_type>(), f_, a, 0);
> }
>
> template<class V> void accept(V & v) const
> {
>
>
> using boost::visit_each;
>
>
> visit_each(v, f_, 0);
> l_.accept(v);
> }
>
> bool compare(this_type const & rhs) const
> {
> return ref_compare(f_, rhs.f_, 0) && l_ == rhs.l_;
> }
>
>private:
>
> F f_;
> L l_;
># 874 "/usr/include/boost/bind/bind.hpp" 2 3 4
>
>
>};
># 940 "/usr/include/boost/bind/bind.hpp" 3 4
>template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )
>{
> return a.compare(b);
>}
># 994 "/usr/include/boost/bind/bind.hpp" 3 4
>template< class T, int I > struct add_value_2
>{
> typedef boost::arg type;
>};
>
>template< class T > struct add_value_2< T, 0 >
>{
> typedef _bi::value< T > type;
>};
>
>template<class T> struct add_value
>{
> typedef typename add_value_2< T, boost::is_placeholder< T >::value >::type type;
>};
>
>
>
>template<class T> struct add_value< value<T> >
>{
> typedef _bi::value<T> type;
>};
>
>template<class T> struct add_value< reference_wrapper<T> >
>{
> typedef reference_wrapper<T> type;
>};
>
>template<int I> struct add_value< arg >
>{
> typedef boost::arg type;
>};
>
>template<int I> struct add_value< arg (*) () >
>{
> typedef boost::arg (*type) ();
>};
>
>template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
>{
> typedef bind_t<R, F, L> type;
>};
># 1077 "/usr/include/boost/bind/bind.hpp" 3 4
>template<class A1> struct list_av_1
>{
> typedef typename add_value<A1>::type B1;
> typedef list1<B1> type;
>};
>
>template<class A1, class A2> struct list_av_2
>{
> typedef typename add_value<A1>::type B1;
> typedef typename add_value<A2>::type B2;
> typedef list2<B1, B2> type;
>};
>
>template<class A1, class A2, class A3> struct list_av_3
>{
> typedef typename add_value<A1>::type B1;
> typedef typename add_value<A2>::type B2;
> typedef typename add_value<A3>::type B3;
> typedef list3<B1, B2, B3> type;
>};
>
>template<class A1, class A2, class A3, class A4> struct list_av_4
>{
> typedef typename add_value<A1>::type B1;
> typedef typename add_value<A2>::type B2;
> typedef typename add_value<A3>::type B3;
> typedef typename add_value<A4>::type B4;
> typedef list4<B1, B2, B3, B4> type;
>};
>
>template<class A1, class A2, class A3, class A4, class A5> struct list_av_5
>{
> typedef typename add_value<A1>::type B1;
> typedef typename add_value<A2>::type B2;
> typedef typename add_value<A3>::type B3;
> typedef typename add_value<A4>::type B4;
> typedef typename add_value<A5>::type B5;
> typedef list5<B1, B2, B3, B4, B5> type;
>};
>
>template<class A1, class A2, class A3, class A4, class A5, class A6> struct list_av_6
>{
> typedef typename add_value<A1>::type B1;
> typedef typename add_value<A2>::type B2;
> typedef typename add_value<A3>::type B3;
> typedef typename add_value<A4>::type B4;
> typedef typename add_value<A5>::type B5;
> typedef typename add_value<A6>::type B6;
> typedef list6<B1, B2, B3, B4, B5, B6> type;
>};
>
>template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct list_av_7
>{
> typedef typename add_value<A1>::type B1;
> typedef typename add_value<A2>::type B2;
> typedef typename add_value<A3>::type B3;
> typedef typename add_value<A4>::type B4;
> typedef typename add_value<A5>::type B5;
> typedef typename add_value<A6>::type B6;
> typedef typename add_value<A7>::type B7;
> typedef list7<B1, B2, B3, B4, B5, B6, B7> type;
>};
>
>template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct list_av_8
>{
> typedef typename add_value<A1>::type B1;
> typedef typename add_value<A2>::type B2;
> typedef typename add_value<A3>::type B3;
> typedef typename add_value<A4>::type B4;
> typedef typename add_value<A5>::type B5;
> typedef typename add_value<A6>::type B6;
> typedef typename add_value<A7>::type B7;
> typedef typename add_value<A8>::type B8;
> typedef list8<B1, B2, B3, B4, B5, B6, B7, B8> type;
>};
>
>template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct list_av_9
>{
> typedef typename add_value<A1>::type B1;
> typedef typename add_value<A2>::type B2;
> typedef typename add_value<A3>::type B3;
> typedef typename add_value<A4>::type B4;
> typedef typename add_value<A5>::type B5;
> typedef typename add_value<A6>::type B6;
> typedef typename add_value<A7>::type B7;
> typedef typename add_value<A8>::type B8;
> typedef typename add_value<A9>::type B9;
> typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
>};
>
>
>
>struct logical_not
>{
> template<class V> bool operator()(V const & v) const { return !v; }
>};
>
>template<class R, class F, class L>
> bind_t< bool, logical_not, list1< bind_t<R, F, L> > >
> operator! (bind_t<R, F, L> const & f)
>{
> typedef list1< bind_t<R, F, L> > list_type;
> return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) );
>}
># 1200 "/usr/include/boost/bind/bind.hpp" 3 4
>struct equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v == w; } }; template<class R, class F, class L, class A2> bind_t< bool, equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator == (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, equal, list_type> ( equal(), list_type(f, a2) ); }
>struct not_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v != w; } }; template<class R, class F, class L, class A2> bind_t< bool, not_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator != (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, not_equal, list_type> ( not_equal(), list_type(f, a2) ); }
>
>struct less { template<class V, class W> bool operator()(V const & v, W const & w) const { return v < w; } }; template<class R, class F, class L, class A2> bind_t< bool, less, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator < (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less, list_type> ( less(), list_type(f, a2) ); }
>struct less_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v <= w; } }; template<class R, class F, class L, class A2> bind_t< bool, less_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator <= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less_equal, list_type> ( less_equal(), list_type(f, a2) ); }
>
>struct greater { template<class V, class W> bool operator()(V const & v, W const & w) const { return v > w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator > (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater, list_type> ( greater(), list_type(f, a2) ); }
>struct greater_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v >= w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator >= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater_equal, list_type> ( greater_equal(), list_type(f, a2) ); }
>
>struct logical_and { template<class V, class W> bool operator()(V const & v, W const & w) const { return v && w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_and, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator && (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_and, list_type> ( logical_and(), list_type(f, a2) ); }
>struct logical_or { template<class V, class W> bool operator()(V const & v, W const & w) const { return v || w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_or, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator || (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_or, list_type> ( logical_or(), list_type(f, a2) ); }
># 1240 "/usr/include/boost/bind/bind.hpp" 3 4
>template<class V, class T> void visit_each( V & v, value<T> const & t, int )
>{
> using boost::visit_each;
> visit_each( v, t.get(), 0 );
>}
>
>template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )
>{
> t.accept( v );
>}
>
>
>
>}
># 1274 "/usr/include/boost/bind/bind.hpp" 3 4
>template< class T > struct is_bind_expression
>{
> enum _vt { value = 0 };
>};
>
>
>
>template< class R, class F, class L > struct is_bind_expression< _bi::bind_t< R, F, L > >
>{
> enum _vt { value = 1 };
>};
># 1296 "/usr/include/boost/bind/bind.hpp" 3 4
>template<class R, class F>
> _bi::bind_t<R, F, _bi::list0>
> bind(F f)
>{
> typedef _bi::list0 list_type;
> return _bi::bind_t<R, F, list_type> (f, list_type());
>}
>
>template<class R, class F, class A1>
> _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
> bind(F f, A1 a1)
>{
> typedef typename _bi::list_av_1<A1>::type list_type;
> return _bi::bind_t<R, F, list_type> (f, list_type(a1));
>}
>
>template<class R, class F, class A1, class A2>
> _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
> bind(F f, A1 a1, A2 a2)
>{
> typedef typename _bi::list_av_2<A1, A2>::type list_type;
> return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
>}
>
>template<class R, class F, class A1, class A2, class A3>
> _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
> bind(F f, A1 a1, A2 a2, A3 a3)
>{
> typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
>}
>
>template<class R, class F, class A1, class A2, class A3, class A4>
> _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
> bind(F f, A1 a1, A2 a2, A3 a3, A4 a4)
>{
> typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
>}
>
>template<class R, class F, class A1, class A2, class A3, class A4, class A5>
> _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
> bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
>{
> typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
>}
>
>template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
> _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
> bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
>{
> typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
>}
>
>template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
> _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
> bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
>{
> typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
>}
>
>template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
> _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
> bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
>{
> typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
>}
>
>template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
> _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
> bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
>{
> typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
>}
>
>
>
>template<class R, class F>
> _bi::bind_t<R, F, _bi::list0>
> bind(boost::type<R>, F f)
>{
> typedef _bi::list0 list_type;
> return _bi::bind_t<R, F, list_type> (f, list_type());
>}
>
>template<class R, class F, class A1>
> _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
> bind(boost::type<R>, F f, A1 a1)
>{
> typedef typename _bi::list_av_1<A1>::type list_type;
> return _bi::bind_t<R, F, list_type> (f, list_type(a1));
>}
>
>template<class R, class F, class A1, class A2>
> _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
> bind(boost::type<R>, F f, A1 a1, A2 a2)
>{
> typedef typename _bi::list_av_2<A1, A2>::type list_type;
> return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
>}
>
>template<class R, class F, class A1, class A2, class A3>
> _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
> bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3)
>{
> typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
>}
>
>template<class R, class F, class A1, class A2, class A3, class A4>
> _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
> bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
>{
> typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
>}
>
>template<class R, class F, class A1, class A2, class A3, class A4, class A5>
> _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
> bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
>{
> typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
>}
>
>template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
> _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
> bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
>{
> typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
>}
>
>template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
> _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
> bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
>{
> typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
>}
>
>template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
> _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
> bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
>{
> typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
>}
>
>template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
> _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
> bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
>{
> typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
>}
>
>
>
>
>
>template<class F>
> _bi::bind_t<_bi::unspecified, F, _bi::list0>
> bind(F f)
>{
> typedef _bi::list0 list_type;
> return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type());
>}
>
>template<class F, class A1>
> _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1<A1>::type>
> bind(F f, A1 a1)
>{
> typedef typename _bi::list_av_1<A1>::type list_type;
> return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1));
>}
>
>template<class F, class A1, class A2>
> _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2<A1, A2>::type>
> bind(F f, A1 a1, A2 a2)
>{
> typedef typename _bi::list_av_2<A1, A2>::type list_type;
> return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2));
>}
>
>template<class F, class A1, class A2, class A3>
> _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3<A1, A2, A3>::type>
> bind(F f, A1 a1, A2 a2, A3 a3)
>{
> typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
> return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3));
>}
>
>template<class F, class A1, class A2, class A3, class A4>
> _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
> bind(F f, A1 a1, A2 a2, A3 a3, A4 a4)
>{
> typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
> return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4));
>}
>
>template<class F, class A1, class A2, class A3, class A4, class A5>
> _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
> bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
>{
> typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
> return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
>}
>
>template<class F, class A1, class A2, class A3, class A4, class A5, class A6>
> _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
> bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
>{
> typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
> return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
>}
>
>template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
> _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
> bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
>{
> typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
> return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
>}
>
>template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
> _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
> bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
>{
> typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
> return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
>}
>
>template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
> _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
> bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
>{
> typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
> return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
>}
># 1549 "/usr/include/boost/bind/bind.hpp" 3 4
># 1 "/usr/include/boost/bind/bind_cc.hpp" 1 3 4
># 15 "/usr/include/boost/bind/bind_cc.hpp" 3 4
>template<class R>
> _bi::bind_t<R, R ( *) (), _bi::list0>
> bind( R ( *f) ())
>{
> typedef R ( *F) ();
> typedef _bi::list0 list_type;
> return _bi::bind_t<R, F, list_type> (f, list_type());
>}
>
>template<class R, class B1, class A1>
> _bi::bind_t<R, R ( *) (B1), typename _bi::list_av_1<A1>::type>
> bind( R ( *f) (B1), A1 a1)
>{
> typedef R ( *F) (B1);
> typedef typename _bi::list_av_1<A1>::type list_type;
> return _bi::bind_t<R, F, list_type> (f, list_type(a1));
>}
>
>template<class R, class B1, class B2, class A1, class A2>
> _bi::bind_t<R, R ( *) (B1, B2), typename _bi::list_av_2<A1, A2>::type>
> bind( R ( *f) (B1, B2), A1 a1, A2 a2)
>{
> typedef R ( *F) (B1, B2);
> typedef typename _bi::list_av_2<A1, A2>::type list_type;
> return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
>}
>
>template<class R,
> class B1, class B2, class B3,
> class A1, class A2, class A3>
> _bi::bind_t<R, R ( *) (B1, B2, B3), typename _bi::list_av_3<A1, A2, A3>::type>
> bind( R ( *f) (B1, B2, B3), A1 a1, A2 a2, A3 a3)
>{
> typedef R ( *F) (B1, B2, B3);
> typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
>}
>
>template<class R,
> class B1, class B2, class B3, class B4,
> class A1, class A2, class A3, class A4>
> _bi::bind_t<R, R ( *) (B1, B2, B3, B4), typename _bi::list_av_4<A1, A2, A3, A4>::type>
> bind( R ( *f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4)
>{
> typedef R ( *F) (B1, B2, B3, B4);
> typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
>}
>
>template<class R,
> class B1, class B2, class B3, class B4, class B5,
> class A1, class A2, class A3, class A4, class A5>
> _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5), typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
> bind( R ( *f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
>{
> typedef R ( *F) (B1, B2, B3, B4, B5);
> typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
>}
>
>template<class R,
> class B1, class B2, class B3, class B4, class B5, class B6,
> class A1, class A2, class A3, class A4, class A5, class A6>
> _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6), typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
> bind( R ( *f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
>{
> typedef R ( *F) (B1, B2, B3, B4, B5, B6);
> typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
>}
>
>template<class R,
> class B1, class B2, class B3, class B4, class B5, class B6, class B7,
> class A1, class A2, class A3, class A4, class A5, class A6, class A7>
> _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7), typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
> bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
>{
> typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7);
> typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
>}
>
>template<class R,
> class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
> class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
> _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8), typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
> bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
>{
> typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8);
> typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
>}
>
>template<class R,
> class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8, class B9,
> class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
> _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8, B9), typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
> bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
>{
> typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9);
> typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
> return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
>}
># 1550 "/usr/include/boost/bind/bind.hpp" 2 3 4
># 1595 "/usr/include/boost/bind/bind.hpp" 3 4
># 1 "/usr/include/boost/bind/bind_mf_cc.hpp" 1 3 4
># 17 "/usr/include/boost/bind/bind_mf_cc.hpp" 3 4
>template<class R, class T,
> class A1>
> _bi::bind_t<R, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
> bind(R ( T::*f) (), A1 a1)
>{
> typedef _mfi::mf0<R, T> F;
> typedef typename _bi::list_av_1<A1>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
>}
>
>template<class R, class T,
> class A1>
> _bi::bind_t<R, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
> bind(R ( T::*f) () const, A1 a1)
>{
> typedef _mfi::cmf0<R, T> F;
> typedef typename _bi::list_av_1<A1>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
>}
>
>
>
>template<class R, class T,
> class B1,
> class A1, class A2>
> _bi::bind_t<R, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
> bind(R ( T::*f) (B1), A1 a1, A2 a2)
>{
> typedef _mfi::mf1<R, T, B1> F;
> typedef typename _bi::list_av_2<A1, A2>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
>}
>
>template<class R, class T,
> class B1,
> class A1, class A2>
> _bi::bind_t<R, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
> bind(R ( T::*f) (B1) const, A1 a1, A2 a2)
>{
> typedef _mfi::cmf1<R, T, B1> F;
> typedef typename _bi::list_av_2<A1, A2>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
>}
>
>
>
>template<class R, class T,
> class B1, class B2,
> class A1, class A2, class A3>
> _bi::bind_t<R, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
> bind(R ( T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
>{
> typedef _mfi::mf2<R, T, B1, B2> F;
> typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
>}
>
>template<class R, class T,
> class B1, class B2,
> class A1, class A2, class A3>
> _bi::bind_t<R, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
> bind(R ( T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
>{
> typedef _mfi::cmf2<R, T, B1, B2> F;
> typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
>}
>
>
>
>template<class R, class T,
> class B1, class B2, class B3,
> class A1, class A2, class A3, class A4>
> _bi::bind_t<R, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
> bind(R ( T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
>{
> typedef _mfi::mf3<R, T, B1, B2, B3> F;
> typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
>}
>
>template<class R, class T,
> class B1, class B2, class B3,
> class A1, class A2, class A3, class A4>
> _bi::bind_t<R, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
> bind(R ( T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
>{
> typedef _mfi::cmf3<R, T, B1, B2, B3> F;
> typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
>}
>
>
>
>template<class R, class T,
> class B1, class B2, class B3, class B4,
> class A1, class A2, class A3, class A4, class A5>
> _bi::bind_t<R, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
> bind(R ( T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
>{
> typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
> typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
>}
>
>template<class R, class T,
> class B1, class B2, class B3, class B4,
> class A1, class A2, class A3, class A4, class A5>
> _bi::bind_t<R, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
> bind(R ( T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
>{
> typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
> typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
>}
>
>
>
>template<class R, class T,
> class B1, class B2, class B3, class B4, class B5,
> class A1, class A2, class A3, class A4, class A5, class A6>
> _bi::bind_t<R, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
> bind(R ( T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
>{
> typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
> typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
>}
>
>template<class R, class T,
> class B1, class B2, class B3, class B4, class B5,
> class A1, class A2, class A3, class A4, class A5, class A6>
> _bi::bind_t<R, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
> bind(R ( T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
>{
> typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
> typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
>}
>
>
>
>template<class R, class T,
> class B1, class B2, class B3, class B4, class B5, class B6,
> class A1, class A2, class A3, class A4, class A5, class A6, class A7>
> _bi::bind_t<R, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
> bind(R ( T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
>{
> typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
> typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
>}
>
>template<class R, class T,
> class B1, class B2, class B3, class B4, class B5, class B6,
> class A1, class A2, class A3, class A4, class A5, class A6, class A7>
> _bi::bind_t<R, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
> bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
>{
> typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
> typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
>}
>
>
>
>template<class R, class T,
> class B1, class B2, class B3, class B4, class B5, class B6, class B7,
> class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
> _bi::bind_t<R, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
> bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
>{
> typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
> typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
>}
>
>template<class R, class T,
> class B1, class B2, class B3, class B4, class B5, class B6, class B7,
> class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
> _bi::bind_t<R, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
> bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
>{
> typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
> typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
>}
>
>
>
>template<class R, class T,
> class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
> class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
> _bi::bind_t<R, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
> bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
>{
> typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
> typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
>}
>
>template<class R, class T,
> class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
> class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
> _bi::bind_t<R, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
> bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
>{
> typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
> typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
> return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
>}
># 1596 "/usr/include/boost/bind/bind.hpp" 2 3 4
># 1 "/usr/include/boost/bind/bind_mf2_cc.hpp" 1 3 4
># 18 "/usr/include/boost/bind/bind_mf2_cc.hpp" 3 4
>template<class Rt2, class R, class T,
> class A1>
> _bi::bind_t<Rt2, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
> bind(boost::type<Rt2>, R ( T::*f) (), A1 a1)
>{
> typedef _mfi::mf0<R, T> F;
> typedef typename _bi::list_av_1<A1>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
>}
>
>template<class Rt2, class R, class T,
> class A1>
> _bi::bind_t<Rt2, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
> bind(boost::type<Rt2>, R ( T::*f) () const, A1 a1)
>{
> typedef _mfi::cmf0<R, T> F;
> typedef typename _bi::list_av_1<A1>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
>}
>
>
>
>template<class Rt2, class R, class T,
> class B1,
> class A1, class A2>
> _bi::bind_t<Rt2, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1), A1 a1, A2 a2)
>{
> typedef _mfi::mf1<R, T, B1> F;
> typedef typename _bi::list_av_2<A1, A2>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
>}
>
>template<class Rt2, class R, class T,
> class B1,
> class A1, class A2>
> _bi::bind_t<Rt2, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1) const, A1 a1, A2 a2)
>{
> typedef _mfi::cmf1<R, T, B1> F;
> typedef typename _bi::list_av_2<A1, A2>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
>}
>
>
>
>template<class Rt2, class R, class T,
> class B1, class B2,
> class A1, class A2, class A3>
> _bi::bind_t<Rt2, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
>{
> typedef _mfi::mf2<R, T, B1, B2> F;
> typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
>}
>
>template<class Rt2, class R, class T,
> class B1, class B2,
> class A1, class A2, class A3>
> _bi::bind_t<Rt2, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
>{
> typedef _mfi::cmf2<R, T, B1, B2> F;
> typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
>}
>
>
>
>template<class Rt2, class R, class T,
> class B1, class B2, class B3,
> class A1, class A2, class A3, class A4>
> _bi::bind_t<Rt2, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
>{
> typedef _mfi::mf3<R, T, B1, B2, B3> F;
> typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
>}
>
>template<class Rt2, class R, class T,
> class B1, class B2, class B3,
> class A1, class A2, class A3, class A4>
> _bi::bind_t<Rt2, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
>{
> typedef _mfi::cmf3<R, T, B1, B2, B3> F;
> typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
>}
>
>
>
>template<class Rt2, class R, class T,
> class B1, class B2, class B3, class B4,
> class A1, class A2, class A3, class A4, class A5>
> _bi::bind_t<Rt2, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
>{
> typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
> typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
>}
>
>template<class Rt2, class R, class T,
> class B1, class B2, class B3, class B4,
> class A1, class A2, class A3, class A4, class A5>
> _bi::bind_t<Rt2, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
>{
> typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
> typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
>}
>
>
>
>template<class Rt2, class R, class T,
> class B1, class B2, class B3, class B4, class B5,
> class A1, class A2, class A3, class A4, class A5, class A6>
> _bi::bind_t<Rt2, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
>{
> typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
> typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
>}
>
>template<class Rt2, class R, class T,
> class B1, class B2, class B3, class B4, class B5,
> class A1, class A2, class A3, class A4, class A5, class A6>
> _bi::bind_t<Rt2, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
>{
> typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
> typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
>}
>
>
>
>template<class Rt2, class R, class T,
> class B1, class B2, class B3, class B4, class B5, class B6,
> class A1, class A2, class A3, class A4, class A5, class A6, class A7>
> _bi::bind_t<Rt2, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
>{
> typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
> typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
>}
>
>template<class Rt2, class R, class T,
> class B1, class B2, class B3, class B4, class B5, class B6,
> class A1, class A2, class A3, class A4, class A5, class A6, class A7>
> _bi::bind_t<Rt2, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
>{
> typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
> typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
>}
>
>
>
>template<class Rt2, class R, class T,
> class B1, class B2, class B3, class B4, class B5, class B6, class B7,
> class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
> _bi::bind_t<Rt2, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
>{
> typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
> typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
>}
>
>template<class Rt2, class R, class T,
> class B1, class B2, class B3, class B4, class B5, class B6, class B7,
> class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
> _bi::bind_t<Rt2, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
>{
> typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
> typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
>}
>
>
>
>template<class Rt2, class R, class T,
> class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
> class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
> _bi::bind_t<Rt2, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
>{
> typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
> typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
>}
>
>template<class Rt2, class R, class T,
> class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
> class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
> _bi::bind_t<Rt2, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
> bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
>{
> typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
> typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
> return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
>}
># 1597 "/usr/include/boost/bind/bind.hpp" 2 3 4
># 1656 "/usr/include/boost/bind/bind.hpp" 3 4
>namespace _bi
>{
>
>template< class Pm, int I > struct add_cref;
>
>template< class M, class T > struct add_cref< M T::*, 0 >
>{
> typedef M type;
>};
>
>template< class M, class T > struct add_cref< M T::*, 1 >
>{
>
>
>
>
> typedef M const & type;
>
>
>
>};
>
>template< class R, class T > struct add_cref< R (T::*) (), 1 >
>{
> typedef void type;
>};
>
>
>
>template< class R, class T > struct add_cref< R (T::*) () const, 1 >
>{
> typedef void type;
>};
>
>
>
>template<class R> struct isref
>{
> enum value_type { value = 0 };
>};
>
>template<class R> struct isref< R& >
>{
> enum value_type { value = 1 };
>};
>
>template<class R> struct isref< R* >
>{
> enum value_type { value = 1 };
>};
>
>template<class Pm, class A1> struct dm_result
>{
> typedef typename add_cref< Pm, 1 >::type type;
>};
>
>template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >
>{
> typedef typename bind_t<R, F, L>::result_type result_type;
> typedef typename add_cref< Pm, isref< result_type >::value >::type type;
>};
>
>}
>
>template< class A1, class M, class T >
>
>_bi::bind_t<
> typename _bi::dm_result< M T::*, A1 >::type,
> _mfi::dm<M, T>,
> typename _bi::list_av_1<A1>::type
>>
>
>bind( M T::*f, A1 a1 )
>{
> typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
> typedef _mfi::dm<M, T> F;
> typedef typename _bi::list_av_1<A1>::type list_type;
> return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );
>}
>
>
>
>}
>
>
>
># 1 "/usr/include/boost/bind/placeholders.hpp" 1 3 4
># 25 "/usr/include/boost/bind/placeholders.hpp" 3 4
>namespace
>{
># 55 "/usr/include/boost/bind/placeholders.hpp" 3 4
>boost::arg<1> _1;
>boost::arg<2> _2;
>boost::arg<3> _3;
>boost::arg<4> _4;
>boost::arg<5> _5;
>boost::arg<6> _6;
>boost::arg<7> _7;
>boost::arg<8> _8;
>boost::arg<9> _9;
>
>
>
>}
># 1743 "/usr/include/boost/bind/bind.hpp" 2 3 4
># 23 "/usr/include/boost/bind.hpp" 2 3 4
># 43 "/usr/include/boost/multi_index/sequenced_index.hpp" 2 3 4
># 54 "/usr/include/boost/multi_index/sequenced_index.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>
>
>template<typename SuperMeta,typename TagList>
>class sequenced_index:
> protected SuperMeta::type
># 78 "/usr/include/boost/multi_index/sequenced_index.hpp" 3 4
>{
># 89 "/usr/include/boost/multi_index/sequenced_index.hpp" 3 4
> typedef typename SuperMeta::type super;
>
>protected:
> typedef sequenced_index_node<
> typename super::node_type> node_type;
>
>private:
> typedef typename node_type::impl_type node_impl_type;
>
>public:
>
>
> typedef typename node_type::value_type value_type;
> typedef tuples::null_type ctor_args;
> typedef typename super::final_allocator_type allocator_type;
> typedef typename allocator_type::reference reference;
> typedef typename allocator_type::const_reference const_reference;
># 119 "/usr/include/boost/multi_index/sequenced_index.hpp" 3 4
> typedef bidir_node_iterator<node_type> iterator;
>
>
> typedef iterator const_iterator;
>
> typedef std::size_t size_type;
> typedef std::ptrdiff_t difference_type;
> typedef typename allocator_type::pointer pointer;
> typedef typename allocator_type::const_pointer const_pointer;
> typedef typename
> boost::reverse_iterator<iterator> reverse_iterator;
> typedef typename
> boost::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef TagList tag_list;
>
>protected:
> typedef typename super::final_node_type final_node_type;
> typedef tuples::cons<
> ctor_args,
> typename super::ctor_args_list> ctor_args_list;
> typedef typename mpl::push_front<
> typename super::index_type_list,
> sequenced_index>::type index_type_list;
> typedef typename mpl::push_front<
> typename super::iterator_type_list,
> iterator>::type iterator_type_list;
> typedef typename mpl::push_front<
> typename super::const_iterator_type_list,
> const_iterator>::type const_iterator_type_list;
> typedef typename super::copy_map_type copy_map_type;
>
>
> typedef typename super::index_saver_type index_saver_type;
> typedef typename super::index_loader_type index_loader_type;
>
>
>private:
># 167 "/usr/include/boost/multi_index/sequenced_index.hpp" 3 4
> typedef typename call_traits<value_type>::param_type value_param_type;
>
>public:
>
>
>
>
>
>
> sequenced_index<SuperMeta,TagList>& operator=(
> const sequenced_index<SuperMeta,TagList>& x)
> {
> this->final()=x.final();
> return *this;
> }
>
> template <class InputIterator>
> void assign(InputIterator first,InputIterator last)
> {
> assign_iter(first,last,mpl::not_<is_integral<InputIterator> >());
> }
>
> void assign(size_type n,value_param_type value)
> {
> ;
> clear();
> for(size_type i=0;i<n;++i)push_back(value);
> }
>
> allocator_type get_allocator()const
> {
> return this->final().get_allocator();
> }
>
>
>
> iterator begin()
> {return make_iterator(node_type::from_impl(header()->next()));}
> const_iterator begin()const
> {return make_iterator(node_type::from_impl(header()->next()));}
> iterator end(){return make_iterator(header());}
> const_iterator end()const{return make_iterator(header());}
> reverse_iterator rbegin(){return make_reverse_iterator(end());}
> const_reverse_iterator rbegin()const{return make_reverse_iterator(end());}
> reverse_iterator rend(){return make_reverse_iterator(begin());}
> const_reverse_iterator rend()const{return make_reverse_iterator(begin());}
> const_iterator cbegin()const{return begin();}
> const_iterator cend()const{return end();}
> const_reverse_iterator crbegin()const{return rbegin();}
> const_reverse_iterator crend()const{return rend();}
>
> iterator iterator_to(const value_type& x)
> {
> return make_iterator(node_from_value<node_type>(&x));
> }
>
> const_iterator iterator_to(const value_type& x)const
> {
> return make_iterator(node_from_value<node_type>(&x));
> }
>
>
>
> bool empty()const{return this->final_empty_();}
> size_type size()const{return this->final_size_();}
> size_type max_size()const{return this->final_max_size_();}
>
> void resize(size_type n,value_param_type x=value_type())
> {
> ;
> if(n>size())insert(end(),n-size(),x);
> else if(n<size()){
> iterator it;
> if(n<=size()/2){
> it=begin();
> std::advance(it,n);
> }
> else{
> it=end();
> for(size_type m=size()-n;m--;--it){}
> }
> erase(it,end());
> }
> }
>
>
>
>
>
> const_reference front()const{return *begin();}
> const_reference back()const{return *--end();}
>
>
>
> std::pair<iterator,bool> push_front(value_param_type x)
> {return insert(begin(),x);}
> void pop_front(){erase(begin());}
> std::pair<iterator,bool> push_back(value_param_type x)
> {return insert(end(),x);}
> void pop_back(){erase(--end());}
>
> std::pair<iterator,bool> insert(iterator position,value_param_type x)
> {
> ((void)0);;
> ((void)0);;
> ;
> std::pair<final_node_type*,bool> p=this->final_insert_(x);
> if(p.second&&position.get_node()!=header()){
> relink(position.get_node(),p.first);
> }
> return std::pair<iterator,bool>(make_iterator(p.first),p.second);
> }
>
> void insert(iterator position,size_type n,value_param_type x)
> {
> ((void)0);;
> ((void)0);;
> ;
> for(size_type i=0;i<n;++i)insert(position,x);
> }
>
> template<typename InputIterator>
> void insert(iterator position,InputIterator first,InputIterator last)
> {
> insert_iter(position,first,last,mpl::not_<is_integral<InputIterator> >());
> }
>
> iterator erase(iterator position)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
> this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
> return position;
> }
>
> iterator erase(iterator first,iterator last)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
> while(first!=last){
> first=erase(first);
> }
> return first;
> }
>
> bool replace(iterator position,value_param_type x)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
> return this->final_replace_(
> x,static_cast<final_node_type*>(position.get_node()));
> }
>
> template<typename Modifier>
> bool modify(iterator position,Modifier mod)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
># 345 "/usr/include/boost/multi_index/sequenced_index.hpp" 3 4
> return this->final_modify_(
> mod,static_cast<final_node_type*>(position.get_node()));
> }
>
> template<typename Modifier,typename Rollback>
> bool modify(iterator position,Modifier mod,Rollback back)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
># 366 "/usr/include/boost/multi_index/sequenced_index.hpp" 3 4
> return this->final_modify_(
> mod,back,static_cast<final_node_type*>(position.get_node()));
> }
>
> void swap(sequenced_index<SuperMeta,TagList>& x)
> {
> ;
> this->final_swap_(x.final());
> }
>
> void clear()
> {
> ;
> this->final_clear_();
> }
>
>
>
> void splice(iterator position,sequenced_index<SuperMeta,TagList>& x)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
> iterator first=x.begin(),last=x.end();
> while(first!=last){
> if(insert(position,*first).second)first=x.erase(first);
> else ++first;
> }
> }
>
> void splice(iterator position,sequenced_index<SuperMeta,TagList>& x,iterator i)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
> if(&x==this){
> if(position!=i)relink(position.get_node(),i.get_node());
> }
> else{
> if(insert(position,*i).second){
># 419 "/usr/include/boost/multi_index/sequenced_index.hpp" 3 4
> x.erase(i);
>
>
> }
> }
> }
>
> void splice(
> iterator position,sequenced_index<SuperMeta,TagList>& x,
> iterator first,iterator last)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
> if(&x==this){
> ((void)0);;
> if(position!=last)relink(
> position.get_node(),first.get_node(),last.get_node());
> }
> else{
> while(first!=last){
> if(insert(position,*first).second)first=x.erase(first);
> else ++first;
> }
> }
> }
>
> void remove(value_param_type value)
> {
> sequenced_index_remove(
> *this,std::bind2nd(std::equal_to<value_type>(),value));
> }
>
> template<typename Predicate>
> void remove_if(Predicate pred)
> {
> sequenced_index_remove(*this,pred);
> }
>
> void unique()
> {
> sequenced_index_unique(*this,std::equal_to<value_type>());
> }
>
> template <class BinaryPredicate>
> void unique(BinaryPredicate binary_pred)
> {
> sequenced_index_unique(*this,binary_pred);
> }
>
> void merge(sequenced_index<SuperMeta,TagList>& x)
> {
> sequenced_index_merge(*this,x,std::less<value_type>());
> }
>
> template <typename Compare>
> void merge(sequenced_index<SuperMeta,TagList>& x,Compare comp)
> {
> sequenced_index_merge(*this,x,comp);
> }
>
> void sort()
> {
> ;
> sequenced_index_sort(header(),std::less<value_type>());
> }
>
> template <typename Compare>
> void sort(Compare comp)
> {
> ;
> sequenced_index_sort(header(),comp);
> }
>
> void reverse()
> {
> ;
> node_impl_type::reverse(header()->impl());
> }
>
>
>
> void relocate(iterator position,iterator i)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
> if(position!=i)relink(position.get_node(),i.get_node());
> }
>
> void relocate(iterator position,iterator first,iterator last)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
> if(position!=last)relink(
> position.get_node(),first.get_node(),last.get_node());
> }
>
> template<typename InputIterator>
> void rearrange(InputIterator first)
> {
> ;
> node_type* pos=header();
> for(size_type s=size();s--;){
> const value_type& v=*first++;
> relink(pos,node_from_value<node_type>(&v));
> }
> }
>
>protected:
> sequenced_index(const ctor_args_list& args_list,const allocator_type& al):
> super(args_list.get_tail(),al)
> {
> empty_initialize();
> }
>
> sequenced_index(const sequenced_index<SuperMeta,TagList>& x):
> super(x)
>
>
>
>
>
> {
>
>
> }
>
> ~sequenced_index()
> {
>
> }
>
>
>
>
>
>
> iterator make_iterator(node_type* node){return iterator(node);}
> const_iterator make_iterator(node_type* node)const
> {return const_iterator(node);}
>
>
> void copy_(
> const sequenced_index<SuperMeta,TagList>& x,const copy_map_type& map)
> {
> node_type* org=x.header();
> node_type* cpy=header();
> do{
> node_type* next_org=node_type::from_impl(org->next());
> node_type* next_cpy=map.find(static_cast<final_node_type*>(next_org));
> cpy->next()=next_cpy->impl();
> next_cpy->prior()=cpy->impl();
> org=next_org;
> cpy=next_cpy;
> }while(org!=x.header());
>
> super::copy_(x,map);
> }
>
> node_type* insert_(value_param_type v,node_type* x)
> {
> node_type* res=static_cast<node_type*>(super::insert_(v,x));
> if(res==x)link(x);
> return res;
> }
>
> node_type* insert_(value_param_type v,node_type* position,node_type* x)
> {
> node_type* res=static_cast<node_type*>(super::insert_(v,position,x));
> if(res==x)link(x);
> return res;
> }
>
> void erase_(node_type* x)
> {
> unlink(x);
> super::erase_(x);
>
>
>
>
> }
>
> void delete_all_nodes_()
> {
> for(node_type* x=node_type::from_impl(header()->next());x!=header();){
> node_type* y=node_type::from_impl(x->next());
> this->final_delete_node_(static_cast<final_node_type*>(x));
> x=y;
> }
> }
>
> void clear_()
> {
> super::clear_();
> empty_initialize();
>
>
>
>
> }
>
> void swap_(sequenced_index<SuperMeta,TagList>& x)
> {
>
>
>
>
> super::swap_(x);
> }
>
> bool replace_(value_param_type v,node_type* x)
> {
> return super::replace_(v,x);
> }
>
> bool modify_(node_type* x)
> {
> { try{
> if(!super::modify_(x)){
> unlink(x);
>
>
>
>
>
> return false;
> }
> else return true;
> }
> catch(...){
> unlink(x);
>
>
>
>
>
> throw;;
> }
> }
> }
>
> bool modify_rollback_(node_type* x)
> {
> return super::modify_rollback_(x);
> }
>
>
>
>
> template<typename Archive>
> void save_(
> Archive& ar,const unsigned int version,const index_saver_type& sm)const
> {
> sm.save(begin(),end(),ar,version);
> super::save_(ar,version,sm);
> }
>
> template<typename Archive>
> void load_(
> Archive& ar,const unsigned int version,const index_loader_type& lm)
> {
> lm.load(
> ::boost::bind(&sequenced_index::rearranger,this,_1,_2),
> ar,version);
> super::load_(ar,version,lm);
> }
># 733 "/usr/include/boost/multi_index/sequenced_index.hpp" 3 4
>private:
> node_type* header()const{return this->final_header();}
>
> void empty_initialize()
> {
> header()->prior()=header()->next()=header()->impl();
> }
>
> void link(node_type* x)
> {
> node_impl_type::link(x->impl(),header()->impl());
> };
>
> static void unlink(node_type* x)
> {
> node_impl_type::unlink(x->impl());
> }
>
> static void relink(node_type* position,node_type* x)
> {
> node_impl_type::relink(position->impl(),x->impl());
> }
>
> static void relink(node_type* position,node_type* first,node_type* last)
> {
> node_impl_type::relink(
> position->impl(),first->impl(),last->impl());
> }
>
>
> void rearranger(node_type* position,node_type *x)
> {
> if(!position)position=header();
> node_type::increment(position);
> if(position!=x)relink(position,x);
> }
># 779 "/usr/include/boost/multi_index/sequenced_index.hpp" 3 4
> template <class InputIterator>
> void assign_iter(InputIterator first,InputIterator last,mpl::true_)
> {
> ;
> clear();
> for(;first!=last;++first)push_back(*first);
> }
>
> void assign_iter(size_type n,value_param_type value,mpl::false_)
> {
> ;
> clear();
> for(size_type i=0;i<n;++i)push_back(value);
> }
>
> template<typename InputIterator>
> void insert_iter(
> iterator position,InputIterator first,InputIterator last,mpl::true_)
> {
> ;
> for(;first!=last;++first)insert(position,*first);
> }
>
> void insert_iter(
> iterator position,size_type n,value_param_type x,mpl::false_)
> {
> ((void)0);;
> ((void)0);;
> ;
> for(size_type i=0;i<n;++i)insert(position,x);
> }
>
>
>
>
>
>};
>
>
>
>template<
> typename SuperMeta1,typename TagList1,
> typename SuperMeta2,typename TagList2
>>
>bool operator==(
> const sequenced_index<SuperMeta1,TagList1>& x,
> const sequenced_index<SuperMeta2,TagList2>& y)
>{
> return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
>}
>
>template<
> typename SuperMeta1,typename TagList1,
> typename SuperMeta2,typename TagList2
>>
>bool operator<(
> const sequenced_index<SuperMeta1,TagList1>& x,
> const sequenced_index<SuperMeta2,TagList2>& y)
>{
> return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
>}
>
>template<
> typename SuperMeta1,typename TagList1,
> typename SuperMeta2,typename TagList2
>>
>bool operator!=(
> const sequenced_index<SuperMeta1,TagList1>& x,
> const sequenced_index<SuperMeta2,TagList2>& y)
>{
> return !(x==y);
>}
>
>template<
> typename SuperMeta1,typename TagList1,
> typename SuperMeta2,typename TagList2
>>
>bool operator>(
> const sequenced_index<SuperMeta1,TagList1>& x,
> const sequenced_index<SuperMeta2,TagList2>& y)
>{
> return y<x;
>}
>
>template<
> typename SuperMeta1,typename TagList1,
> typename SuperMeta2,typename TagList2
>>
>bool operator>=(
> const sequenced_index<SuperMeta1,TagList1>& x,
> const sequenced_index<SuperMeta2,TagList2>& y)
>{
> return !(x<y);
>}
>
>template<
> typename SuperMeta1,typename TagList1,
> typename SuperMeta2,typename TagList2
>>
>bool operator<=(
> const sequenced_index<SuperMeta1,TagList1>& x,
> const sequenced_index<SuperMeta2,TagList2>& y)
>{
> return !(x>y);
>}
>
>
>
>template<typename SuperMeta,typename TagList>
>void swap(
> sequenced_index<SuperMeta,TagList>& x,
> sequenced_index<SuperMeta,TagList>& y)
>{
> x.swap(y);
>}
>
>}
>
>
>
>template <typename TagList>
>struct sequenced
>{
> static_assert(detail::is_tag<TagList>::value, "detail::is_tag<TagList>::value");
>
> template<typename Super>
> struct node_class
> {
> typedef detail::sequenced_index_node<Super> type;
> };
>
> template<typename SuperMeta>
> struct index_class
> {
> typedef detail::sequenced_index<SuperMeta,typename TagList::type> type;
> };
>};
>
>}
>
>}
>
>
>
>template<typename SuperMeta,typename TagList>
>inline boost::mpl::true_* boost_foreach_is_noncopyable(
> boost::multi_index::detail::sequenced_index<SuperMeta,TagList>*&,
> boost::foreach::tag)
>{
> return 0;
>}
># 24 "/usr/include/boost/property_tree/ptree.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/ordered_index.hpp" 1 3 4
># 56 "/usr/include/boost/multi_index/ordered_index.hpp" 3 4
># 1 "/usr/include/boost/multi_index/detail/modify_key_adaptor.hpp" 1 3 4
># 16 "/usr/include/boost/multi_index/detail/modify_key_adaptor.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>
>
>
>
>
>template<typename Fun,typename Value,typename KeyFromValue>
>struct modify_key_adaptor
>{
>
> modify_key_adaptor(Fun f_,KeyFromValue kfv_):f(f_),kfv(kfv_){}
>
> void operator()(Value& x)
> {
> f(kfv(x));
> }
>
>private:
> Fun f;
> KeyFromValue kfv;
>};
>
>}
>
>}
>
>}
># 57 "/usr/include/boost/multi_index/ordered_index.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/detail/ord_index_node.hpp" 1 3 4
># 44 "/usr/include/boost/multi_index/detail/ord_index_node.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 45 "/usr/include/boost/multi_index/detail/ord_index_node.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/multi_index/detail/uintptr_type.hpp" 1 3 4
># 19 "/usr/include/boost/multi_index/detail/uintptr_type.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
># 35 "/usr/include/boost/multi_index/detail/uintptr_type.hpp" 3 4
>template<int N>struct uintptr_candidates;
>template<>struct uintptr_candidates<-1>{typedef unsigned int type;};
>template<>struct uintptr_candidates<0> {typedef unsigned int type;};
>template<>struct uintptr_candidates<1> {typedef unsigned short type;};
>template<>struct uintptr_candidates<2> {typedef unsigned long type;};
>
>
>template<>struct uintptr_candidates<3> {typedef boost::ulong_long_type type;};
>
>
>
>
>
>
>
>template<>struct uintptr_candidates<4> {typedef unsigned int type;};
>
>
>struct uintptr_aux
>{
> static const int index= sizeof(void*)==sizeof(uintptr_candidates<0>::type)?0: sizeof(void*)==sizeof(uintptr_candidates<1>::type)?1: sizeof(void*)==sizeof(uintptr_candidates<2>::type)?2: sizeof(void*)==sizeof(uintptr_candidates<3>::type)?3: sizeof(void*)==sizeof(uintptr_candidates<4>::type)?4:-1
>
>
>
>
> ;
>
> static const bool has_uintptr_type=(index>=0);
>
> typedef uintptr_candidates<index>::type type;
>};
>
>typedef mpl::bool_<uintptr_aux::has_uintptr_type> has_uintptr_type;
>typedef uintptr_aux::type uintptr_type;
>
>}
>
>}
>
>}
># 52 "/usr/include/boost/multi_index/detail/ord_index_node.hpp" 2 3 4
>
>
>
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>
>
>enum ordered_index_color{red=false,black=true};
>enum ordered_index_side{to_left=false,to_right=true};
>
>template<typename Allocator>
>struct ordered_index_node_impl;
>
>template<typename Allocator>
>struct ordered_index_node_std_base
>{
> typedef typename prevent_eti<
> Allocator,
> typename boost::detail::allocator::rebind_to<
> Allocator,
> ordered_index_node_impl<Allocator>
> >::type
> >::type::pointer pointer;
> typedef typename prevent_eti<
> Allocator,
> typename boost::detail::allocator::rebind_to<
> Allocator,
> ordered_index_node_impl<Allocator>
> >::type
> >::type::const_pointer const_pointer;
> typedef ordered_index_color& color_ref;
> typedef pointer& parent_ref;
>
> ordered_index_color& color(){return color_;}
> ordered_index_color color()const{return color_;}
> pointer& parent(){return parent_;}
> pointer parent()const{return parent_;}
> pointer& left(){return left_;}
> pointer left()const{return left_;}
> pointer& right(){return right_;}
> pointer right()const{return right_;}
>
>private:
> ordered_index_color color_;
> pointer parent_;
> pointer left_;
> pointer right_;
>};
># 124 "/usr/include/boost/multi_index/detail/ord_index_node.hpp" 3 4
>template<typename Allocator>
>struct ordered_index_node_compressed_base
>{
> typedef ordered_index_node_impl<Allocator>* pointer;
> typedef const ordered_index_node_impl<Allocator>* const_pointer;
>
> struct color_ref
> {
> color_ref(uintptr_type* r_):r(r_){}
>
> operator ordered_index_color()const
> {
> return ordered_index_color(*r&uintptr_type(1));
> }
>
> color_ref& operator=(ordered_index_color c)
> {
> *r&=~uintptr_type(1);
> *r|=uintptr_type(c);
> return *this;
> }
>
> color_ref& operator=(const color_ref& x)
> {
> return operator=(x.operator ordered_index_color());
> }
>
> private:
> uintptr_type* r;
> };
>
> struct parent_ref
> {
> parent_ref(uintptr_type* r_):r(r_){}
>
> operator pointer()const
> {
> return (pointer)(void*)(*r&~uintptr_type(1));
> }
>
> parent_ref& operator=(pointer p)
> {
> *r=((uintptr_type)(void*)p)|(*r&uintptr_type(1));
> return *this;
> }
>
> parent_ref& operator=(const parent_ref& x)
> {
> return operator=(x.operator pointer());
> }
>
> pointer operator->()const
> {
> return operator pointer();
> }
>
> private:
> uintptr_type* r;
> };
>
> color_ref color(){return color_ref(&parentcolor_);}
> ordered_index_color color()const
> {
> return ordered_index_color(parentcolor_&std::size_t(1ul));
> }
>
> parent_ref parent(){return parent_ref(&parentcolor_);}
> pointer parent()const
> {
> return (pointer)(void*)(parentcolor_&~uintptr_type(1));
> }
>
> pointer& left(){return left_;}
> pointer left()const{return left_;}
> pointer& right(){return right_;}
> pointer right()const{return right_;}
>
>private:
> uintptr_type parentcolor_;
> pointer left_;
> pointer right_;
>};
>
>
>
>
>
>template<typename Allocator>
>struct ordered_index_node_impl_base:
>
>
> mpl::if_c<
> !(has_uintptr_type::value)||
> (alignment_of<ordered_index_node_compressed_base<Allocator> >::value%2)||
> !(is_same<
> typename prevent_eti<
> Allocator,
> typename boost::detail::allocator::rebind_to<
> Allocator,
> ordered_index_node_impl<Allocator>
> >::type
> >::type::pointer,
> ordered_index_node_impl<Allocator>*>::value),
> ordered_index_node_std_base<Allocator>,
> ordered_index_node_compressed_base<Allocator>
> >::type
>
>
>
>
>{};
>
>template<typename Allocator>
>struct ordered_index_node_impl:ordered_index_node_impl_base<Allocator>
>{
>private:
> typedef ordered_index_node_impl_base<Allocator> super;
>
>public:
> typedef typename super::color_ref color_ref;
> typedef typename super::parent_ref parent_ref;
> typedef typename super::pointer pointer;
> typedef typename super::const_pointer const_pointer;
>
>
>
> static void increment(pointer& x)
> {
> if(x->right()!=pointer(0)){
> x=x->right();
> while(x->left()!=pointer(0))x=x->left();
> }
> else{
> pointer y=x->parent();
> while(x==y->right()){
> x=y;
> y=y->parent();
> }
> if(x->right()!=y)x=y;
> }
> }
>
> static void decrement(pointer& x)
> {
> if(x->color()==red&&x->parent()->parent()==x){
> x=x->right();
> }
> else if(x->left()!=pointer(0)){
> pointer y=x->left();
> while(y->right()!=pointer(0))y=y->right();
> x=y;
> }else{
> pointer y=x->parent();
> while(x==y->left()){
> x=y;
> y=y->parent();
> }
> x=y;
> }
> }
>
>
>
> static void rotate_left(pointer x,parent_ref root)
> {
> pointer y=x->right();
> x->right()=y->left();
> if(y->left()!=pointer(0))y->left()->parent()=x;
> y->parent()=x->parent();
>
> if(x==root) root=y;
> else if(x==x->parent()->left())x->parent()->left()=y;
> else x->parent()->right()=y;
> y->left()=x;
> x->parent()=y;
> }
>
> static pointer minimum(pointer x)
> {
> while(x->left()!=pointer(0))x=x->left();
> return x;
> }
>
> static pointer maximum(pointer x)
> {
> while(x->right()!=pointer(0))x=x->right();
> return x;
> }
>
> static void rotate_right(pointer x,parent_ref root)
> {
> pointer y=x->left();
> x->left()=y->right();
> if(y->right()!=pointer(0))y->right()->parent()=x;
> y->parent()=x->parent();
>
> if(x==root) root=y;
> else if(x==x->parent()->right())x->parent()->right()=y;
> else x->parent()->left()=y;
> y->right()=x;
> x->parent()=y;
> }
>
> static void rebalance(pointer x,parent_ref root)
> {
> x->color()=red;
> while(x!=root&&x->parent()->color()==red){
> if(x->parent()==x->parent()->parent()->left()){
> pointer y=x->parent()->parent()->right();
> if(y!=pointer(0)&&y->color()==red){
> x->parent()->color()=black;
> y->color()=black;
> x->parent()->parent()->color()=red;
> x=x->parent()->parent();
> }
> else{
> if(x==x->parent()->right()){
> x=x->parent();
> rotate_left(x,root);
> }
> x->parent()->color()=black;
> x->parent()->parent()->color()=red;
> rotate_right(x->parent()->parent(),root);
> }
> }
> else{
> pointer y=x->parent()->parent()->left();
> if(y!=pointer(0)&&y->color()==red){
> x->parent()->color()=black;
> y->color()=black;
> x->parent()->parent()->color()=red;
> x=x->parent()->parent();
> }
> else{
> if(x==x->parent()->left()){
> x=x->parent();
> rotate_right(x,root);
> }
> x->parent()->color()=black;
> x->parent()->parent()->color()=red;
> rotate_left(x->parent()->parent(),root);
> }
> }
> }
> root->color()=black;
> }
>
> static void link(
> pointer x,ordered_index_side side,pointer position,pointer header)
> {
> if(side==to_left){
> position->left()=x;
> if(position==header){
> header->parent()=x;
> header->right()=x;
> }
> else if(position==header->left()){
> header->left()=x;
> }
> }
> else{
> position->right()=x;
> if(position==header->right()){
> header->right()=x;
> }
> }
> x->parent()=position;
> x->left()=pointer(0);
> x->right()=pointer(0);
> ordered_index_node_impl::rebalance(x,header->parent());
> }
>
> static pointer rebalance_for_erase(
> pointer z,parent_ref root,pointer& leftmost,pointer& rightmost)
> {
> pointer y=z;
> pointer x=pointer(0);
> pointer x_parent=pointer(0);
> if(y->left()==pointer(0)){
> x=y->right();
> }
> else{
> if(y->right()==pointer(0)){
> x=y->left();
> }
> else{
> y=y->right();
> while(y->left()!=pointer(0))y=y->left();
> x=y->right();
> }
> }
> if(y!=z){
> z->left()->parent()=y;
> y->left()=z->left();
> if(y!=z->right()){
> x_parent=y->parent();
> if(x!=pointer(0))x->parent()=y->parent();
> y->parent()->left()=x;
> y->right()=z->right();
> z->right()->parent()=y;
> }
> else{
> x_parent=y;
> }
>
> if(root==z) root=y;
> else if(z->parent()->left()==z)z->parent()->left()=y;
> else z->parent()->right()=y;
> y->parent()=z->parent();
> ordered_index_color c=y->color();
> y->color()=z->color();
> z->color()=c;
> y=z;
> }
> else{
> x_parent=y->parent();
> if(x!=pointer(0))x->parent()=y->parent();
> if(root==z){
> root=x;
> }
> else{
> if(z->parent()->left()==z)z->parent()->left()=x;
> else z->parent()->right()=x;
> }
> if(leftmost==z){
> if(z->right()==pointer(0)){
> leftmost=z->parent();
> }
> else{
> leftmost=minimum(x);
> }
> }
> if(rightmost==z){
> if(z->left()==pointer(0)){
> rightmost=z->parent();
> }
> else{
> rightmost=maximum(x);
> }
> }
> }
> if(y->color()!=red){
> while(x!=root&&(x==pointer(0)|| x->color()==black)){
> if(x==x_parent->left()){
> pointer w=x_parent->right();
> if(w->color()==red){
> w->color()=black;
> x_parent->color()=red;
> rotate_left(x_parent,root);
> w=x_parent->right();
> }
> if((w->left()==pointer(0)||w->left()->color()==black) &&
> (w->right()==pointer(0)||w->right()->color()==black)){
> w->color()=red;
> x=x_parent;
> x_parent=x_parent->parent();
> }
> else{
> if(w->right()==pointer(0 )
> || w->right()->color()==black){
> if(w->left()!=pointer(0)) w->left()->color()=black;
> w->color()=red;
> rotate_right(w,root);
> w=x_parent->right();
> }
> w->color()=x_parent->color();
> x_parent->color()=black;
> if(w->right()!=pointer(0))w->right()->color()=black;
> rotate_left(x_parent,root);
> break;
> }
> }
> else{
> pointer w=x_parent->left();
> if(w->color()==red){
> w->color()=black;
> x_parent->color()=red;
> rotate_right(x_parent,root);
> w=x_parent->left();
> }
> if((w->right()==pointer(0)||w->right()->color()==black) &&
> (w->left()==pointer(0)||w->left()->color()==black)){
> w->color()=red;
> x=x_parent;
> x_parent=x_parent->parent();
> }
> else{
> if(w->left()==pointer(0)||w->left()->color()==black){
> if(w->right()!=pointer(0))w->right()->color()=black;
> w->color()=red;
> rotate_left(w,root);
> w=x_parent->left();
> }
> w->color()=x_parent->color();
> x_parent->color()=black;
> if(w->left()!=pointer(0))w->left()->color()=black;
> rotate_right(x_parent,root);
> break;
> }
> }
> }
> if(x!=pointer(0))x->color()=black;
> }
> return y;
> }
>
> static void restore(pointer x,pointer position,pointer header)
> {
> if(position->left()==pointer(0)||position->left()==header){
> link(x,to_left,position,header);
> }
> else{
> decrement(position);
> link(x,to_right,position,header);
> }
> }
># 556 "/usr/include/boost/multi_index/detail/ord_index_node.hpp" 3 4
>};
>
>template<typename Super>
>struct ordered_index_node_trampoline:
> prevent_eti<
> Super,
> ordered_index_node_impl<
> typename boost::detail::allocator::rebind_to<
> typename Super::allocator_type,
> char
> >::type
> >
> >::type
>{
> typedef typename prevent_eti<
> Super,
> ordered_index_node_impl<
> typename boost::detail::allocator::rebind_to<
> typename Super::allocator_type,
> char
> >::type
> >
> >::type impl_type;
>};
>
>template<typename Super>
>struct ordered_index_node:Super,ordered_index_node_trampoline<Super>
>{
>private:
> typedef ordered_index_node_trampoline<Super> trampoline;
>
>public:
> typedef typename trampoline::impl_type impl_type;
> typedef typename trampoline::color_ref impl_color_ref;
> typedef typename trampoline::parent_ref impl_parent_ref;
> typedef typename trampoline::pointer impl_pointer;
> typedef typename trampoline::const_pointer const_impl_pointer;
>
> impl_color_ref color(){return trampoline::color();}
> ordered_index_color color()const{return trampoline::color();}
> impl_parent_ref parent(){return trampoline::parent();}
> impl_pointer parent()const{return trampoline::parent();}
> impl_pointer& left(){return trampoline::left();}
> impl_pointer left()const{return trampoline::left();}
> impl_pointer& right(){return trampoline::right();}
> impl_pointer right()const{return trampoline::right();}
>
> impl_pointer impl()
> {
> return static_cast<impl_pointer>(
> static_cast<impl_type*>(static_cast<trampoline*>(this)));
> }
>
> const_impl_pointer impl()const
> {
> return static_cast<const_impl_pointer>(
> static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
> }
>
> static ordered_index_node* from_impl(impl_pointer x)
> {
> return static_cast<ordered_index_node*>(
> static_cast<trampoline*>(&*x));
> }
>
> static const ordered_index_node* from_impl(const_impl_pointer x)
> {
> return static_cast<const ordered_index_node*>(
> static_cast<const trampoline*>(&*x));
> }
>
>
>
> static void increment(ordered_index_node*& x)
> {
> impl_pointer xi=x->impl();
> trampoline::increment(xi);
> x=from_impl(xi);
> }
>
> static void decrement(ordered_index_node*& x)
> {
> impl_pointer xi=x->impl();
> trampoline::decrement(xi);
> x=from_impl(xi);
> }
>};
>
>}
>
>}
>
>}
># 58 "/usr/include/boost/multi_index/ordered_index.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/detail/ord_index_ops.hpp" 1 3 4
># 46 "/usr/include/boost/multi_index/detail/ord_index_ops.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>
>
>
>
>template<
> typename Node,typename KeyFromValue,
> typename CompatibleKey,typename CompatibleCompare
>>
>inline Node* ordered_index_find(
> Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
> const CompatibleCompare& comp)
>{
> Node* y0=y;
>
> while (top){
> if(!comp(key(top->value()),x)){
> y=top;
> top=Node::from_impl(top->left());
> }
> else top=Node::from_impl(top->right());
> }
>
> return (y==y0||comp(x,key(y->value())))?y0:y;
>}
>
>template<
> typename Node,typename KeyFromValue,
> typename CompatibleKey,typename CompatibleCompare
>>
>inline Node* ordered_index_lower_bound(
> Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
> const CompatibleCompare& comp)
>{
> while(top){
> if(!comp(key(top->value()),x)){
> y=top;
> top=Node::from_impl(top->left());
> }
> else top=Node::from_impl(top->right());
> }
>
> return y;
>}
>
>template<
> typename Node,typename KeyFromValue,
> typename CompatibleKey,typename CompatibleCompare
>>
>inline Node* ordered_index_upper_bound(
> Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
> const CompatibleCompare& comp)
>{
> while(top){
> if(comp(x,key(top->value()))){
> y=top;
> top=Node::from_impl(top->left());
> }
> else top=Node::from_impl(top->right());
> }
>
> return y;
>}
>
>template<
> typename Node,typename KeyFromValue,
> typename CompatibleKey,typename CompatibleCompare
>>
>inline std::pair<Node*,Node*> ordered_index_equal_range(
> Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
> const CompatibleCompare& comp)
>{
> while(top){
> if(comp(key(top->value()),x)){
> top=Node::from_impl(top->right());
> }
> else if(comp(x,key(top->value()))){
> y=top;
> top=Node::from_impl(top->left());
> }
> else{
> return std::pair<Node*,Node*>(
> ordered_index_lower_bound(Node::from_impl(top->left()),top,key,x,comp),
> ordered_index_upper_bound(Node::from_impl(top->right()),y,key,x,comp));
> }
> }
>
> return std::pair<Node*,Node*>(y,y);
>}
>
>}
>
>}
>
>}
># 59 "/usr/include/boost/multi_index/ordered_index.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/multi_index/detail/unbounded.hpp" 1 3 4
># 19 "/usr/include/boost/multi_index/detail/unbounded.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
># 45 "/usr/include/boost/multi_index/detail/unbounded.hpp" 3 4
>namespace detail{class unbounded_helper;}
>
>detail::unbounded_helper unbounded(detail::unbounded_helper);
>
>namespace detail{
>
>class unbounded_helper
>{
> unbounded_helper(){}
> unbounded_helper(const unbounded_helper&){}
> friend unbounded_helper multi_index::unbounded(unbounded_helper);
>};
>
>typedef unbounded_helper (*unbounded_type)(unbounded_helper);
>
>}
>
>inline detail::unbounded_helper unbounded(detail::unbounded_helper)
>{
> return detail::unbounded_helper();
>}
>
>
>
>
>namespace detail{
>
>struct none_unbounded_tag{};
>struct lower_unbounded_tag{};
>struct upper_unbounded_tag{};
>struct both_unbounded_tag{};
>
>}
>
>}
>
>}
># 63 "/usr/include/boost/multi_index/ordered_index.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/detail/value_compare.hpp" 1 3 4
># 20 "/usr/include/boost/multi_index/detail/value_compare.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>template<typename Value,typename KeyFromValue,typename Compare>
>struct value_comparison:std::binary_function<Value,Value,bool>
>{
> value_comparison(
> const KeyFromValue& key_=KeyFromValue(),const Compare& comp_=Compare()):
> key(key_),comp(comp_)
> {
> }
>
> bool operator()(
> typename call_traits<Value>::param_type x,
> typename call_traits<Value>::param_type y)const
> {
> return comp(key(x),key(y));
> }
>
>private:
> KeyFromValue key;
> Compare comp;
>};
>
>}
>
>}
>
>}
># 64 "/usr/include/boost/multi_index/ordered_index.hpp" 2 3 4
># 73 "/usr/include/boost/multi_index/ordered_index.hpp" 3 4
># 1 "/usr/include/boost/multi_index/detail/duplicates_iterator.hpp" 1 3 4
># 17 "/usr/include/boost/multi_index/detail/duplicates_iterator.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 18 "/usr/include/boost/multi_index/detail/duplicates_iterator.hpp" 2 3 4
>
>
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
>
>
>
>
>
>template<typename Node,typename Predicate>
>class duplicates_iterator
>{
>public:
> typedef typename Node::value_type value_type;
> typedef std::ptrdiff_t difference_type;
> typedef const typename Node::value_type* pointer;
> typedef const typename Node::value_type& reference;
> typedef std::forward_iterator_tag iterator_category;
>
> duplicates_iterator(Node* node_,Node* end_,Predicate pred_):
> node(node_),begin_chunk(0),end(end_),pred(pred_)
> {
> advance();
> }
>
> duplicates_iterator(Node* end_,Predicate pred_):
> node(end_),begin_chunk(end_),end(end_),pred(pred_)
> {
> }
>
> reference operator*()const
> {
> return node->value();
> }
>
> pointer operator->()const
> {
> return &node->value();
> }
>
> duplicates_iterator& operator++()
> {
> Node::increment(node);
> sync();
> return *this;
> }
>
> duplicates_iterator operator++(int)
> {
> duplicates_iterator tmp(*this);
> ++(*this);
> return tmp;
> }
>
> Node* get_node()const{return node;}
>
>private:
> void sync()
> {
> if(node!=end&&pred(begin_chunk->value(),node->value()))advance();
> }
>
> void advance()
> {
> for(Node* node2=node;node!=end;node=node2){
> Node::increment(node2);
> if(node2!=end&&!pred(node->value(),node2->value()))break;
> }
> begin_chunk=node;
> }
>
> Node* node;
> Node* begin_chunk;
> Node* end;
> Predicate pred;
>};
>
>template<typename Node,typename Predicate>
>bool operator==(
> const duplicates_iterator<Node,Predicate>& x,
> const duplicates_iterator<Node,Predicate>& y)
>{
> return x.get_node()==y.get_node();
>}
>
>template<typename Node,typename Predicate>
>bool operator!=(
> const duplicates_iterator<Node,Predicate>& x,
> const duplicates_iterator<Node,Predicate>& y)
>{
> return !(x==y);
>}
>
>}
>
>}
>
>}
># 74 "/usr/include/boost/multi_index/ordered_index.hpp" 2 3 4
># 86 "/usr/include/boost/multi_index/ordered_index.hpp" 3 4
>namespace boost{
>
>namespace multi_index{
>
>namespace detail{
># 99 "/usr/include/boost/multi_index/ordered_index.hpp" 3 4
>struct ordered_unique_tag{};
>struct ordered_non_unique_tag{};
>
>template<
> typename KeyFromValue,typename Compare,
> typename SuperMeta,typename TagList,typename Category
>>
>class ordered_index:
> protected SuperMeta::type
># 121 "/usr/include/boost/multi_index/ordered_index.hpp" 3 4
>{
># 132 "/usr/include/boost/multi_index/ordered_index.hpp" 3 4
> typedef typename SuperMeta::type super;
>
>protected:
> typedef ordered_index_node<
> typename super::node_type> node_type;
>
>private:
> typedef typename node_type::impl_type node_impl_type;
> typedef typename node_impl_type::pointer node_impl_pointer;
>
>public:
>
>
> typedef typename KeyFromValue::result_type key_type;
> typedef typename node_type::value_type value_type;
> typedef KeyFromValue key_from_value;
> typedef Compare key_compare;
> typedef value_comparison<
> value_type,KeyFromValue,Compare> value_compare;
> typedef tuple<key_from_value,key_compare> ctor_args;
> typedef typename super::final_allocator_type allocator_type;
> typedef typename allocator_type::reference reference;
> typedef typename allocator_type::const_reference const_reference;
># 168 "/usr/include/boost/multi_index/ordered_index.hpp" 3 4
> typedef bidir_node_iterator<node_type> iterator;
>
>
> typedef iterator const_iterator;
>
> typedef std::size_t size_type;
> typedef std::ptrdiff_t difference_type;
> typedef typename allocator_type::pointer pointer;
> typedef typename allocator_type::const_pointer const_pointer;
> typedef typename
> boost::reverse_iterator<iterator> reverse_iterator;
> typedef typename
> boost::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef TagList tag_list;
>
>protected:
> typedef typename super::final_node_type final_node_type;
> typedef tuples::cons<
> ctor_args,
> typename super::ctor_args_list> ctor_args_list;
> typedef typename mpl::push_front<
> typename super::index_type_list,
> ordered_index>::type index_type_list;
> typedef typename mpl::push_front<
> typename super::iterator_type_list,
> iterator>::type iterator_type_list;
> typedef typename mpl::push_front<
> typename super::const_iterator_type_list,
> const_iterator>::type const_iterator_type_list;
> typedef typename super::copy_map_type copy_map_type;
>
>
> typedef typename super::index_saver_type index_saver_type;
> typedef typename super::index_loader_type index_loader_type;
>
>
>private:
># 215 "/usr/include/boost/multi_index/ordered_index.hpp" 3 4
> typedef typename call_traits<
> value_type>::param_type value_param_type;
> typedef typename call_traits<
> key_type>::param_type key_param_type;
>
>public:
>
>
>
>
>
>
> ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& operator=(
> const ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x)
> {
> this->final()=x.final();
> return *this;
> }
>
> allocator_type get_allocator()const
> {
> return this->final().get_allocator();
> }
>
>
>
> iterator begin(){return make_iterator(leftmost());}
> const_iterator begin()const{return make_iterator(leftmost());}
> iterator end(){return make_iterator(header());}
> const_iterator end()const{return make_iterator(header());}
> reverse_iterator rbegin(){return make_reverse_iterator(end());}
> const_reverse_iterator rbegin()const{return make_reverse_iterator(end());}
> reverse_iterator rend(){return make_reverse_iterator(begin());}
> const_reverse_iterator rend()const{return make_reverse_iterator(begin());}
> const_iterator cbegin()const{return begin();}
> const_iterator cend()const{return end();}
> const_reverse_iterator crbegin()const{return rbegin();}
> const_reverse_iterator crend()const{return rend();}
>
> iterator iterator_to(const value_type& x)
> {
> return make_iterator(node_from_value<node_type>(&x));
> }
>
> const_iterator iterator_to(const value_type& x)const
> {
> return make_iterator(node_from_value<node_type>(&x));
> }
>
>
>
> bool empty()const{return this->final_empty_();}
> size_type size()const{return this->final_size_();}
> size_type max_size()const{return this->final_max_size_();}
>
>
>
> std::pair<iterator,bool> insert(value_param_type x)
> {
> ;
> std::pair<final_node_type*,bool> p=this->final_insert_(x);
> return std::pair<iterator,bool>(make_iterator(p.first),p.second);
> }
>
> iterator insert(iterator position,value_param_type x)
> {
> ((void)0);;
> ((void)0);;
> ;
> std::pair<final_node_type*,bool> p=this->final_insert_(
> x,static_cast<final_node_type*>(position.get_node()));
> return make_iterator(p.first);
> }
>
> template<typename InputIterator>
> void insert(InputIterator first,InputIterator last)
> {
> ;
> iterator hint=end();
> for(;first!=last;++first)hint=insert(hint,*first);
> }
>
> iterator erase(iterator position)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
> this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
> return position;
> }
>
> size_type erase(key_param_type x)
> {
> ;
> std::pair<iterator,iterator> p=equal_range(x);
> size_type s=0;
> while(p.first!=p.second){
> p.first=erase(p.first);
> ++s;
> }
> return s;
> }
>
> iterator erase(iterator first,iterator last)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
> while(first!=last){
> first=erase(first);
> }
> return first;
> }
>
> bool replace(iterator position,value_param_type x)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
> return this->final_replace_(
> x,static_cast<final_node_type*>(position.get_node()));
> }
>
> template<typename Modifier>
> bool modify(iterator position,Modifier mod)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
># 360 "/usr/include/boost/multi_index/ordered_index.hpp" 3 4
> return this->final_modify_(
> mod,static_cast<final_node_type*>(position.get_node()));
> }
>
> template<typename Modifier,typename Rollback>
> bool modify(iterator position,Modifier mod,Rollback back)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
># 381 "/usr/include/boost/multi_index/ordered_index.hpp" 3 4
> return this->final_modify_(
> mod,back,static_cast<final_node_type*>(position.get_node()));
> }
>
> template<typename Modifier>
> bool modify_key(iterator position,Modifier mod)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
> return modify(
> position,modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key));
> }
>
> template<typename Modifier,typename Rollback>
> bool modify_key(iterator position,Modifier mod,Rollback back)
> {
> ((void)0);;
> ((void)0);;
> ((void)0);;
> ;
> return modify(
> position,
> modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key),
> modify_key_adaptor<Rollback,value_type,KeyFromValue>(back,key));
> }
>
> void swap(ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x)
> {
> ;
> this->final_swap_(x.final());
> }
>
> void clear()
> {
> ;
> this->final_clear_();
> }
>
>
>
> key_from_value key_extractor()const{return key;}
> key_compare key_comp()const{return comp_;}
> value_compare value_comp()const{return value_compare(key,comp_);}
>
>
>
>
>
>
>
> template<typename CompatibleKey>
> iterator find(const CompatibleKey& x)const
> {
> return make_iterator(ordered_index_find(root(),header(),key,x,comp_));
> }
>
> template<typename CompatibleKey,typename CompatibleCompare>
> iterator find(
> const CompatibleKey& x,const CompatibleCompare& comp)const
> {
> return make_iterator(ordered_index_find(root(),header(),key,x,comp));
> }
>
> template<typename CompatibleKey>
> size_type count(const CompatibleKey& x)const
> {
> return count(x,comp_);
> }
>
> template<typename CompatibleKey,typename CompatibleCompare>
> size_type count(const CompatibleKey& x,const CompatibleCompare& comp)const
> {
> std::pair<iterator,iterator> p=equal_range(x,comp);
> size_type n=std::distance(p.first,p.second);
> return n;
> }
>
> template<typename CompatibleKey>
> iterator lower_bound(const CompatibleKey& x)const
> {
> return make_iterator(
> ordered_index_lower_bound(root(),header(),key,x,comp_));
> }
>
> template<typename CompatibleKey,typename CompatibleCompare>
> iterator lower_bound(
> const CompatibleKey& x,const CompatibleCompare& comp)const
> {
> return make_iterator(
> ordered_index_lower_bound(root(),header(),key,x,comp));
> }
>
> template<typename CompatibleKey>
> iterator upper_bound(const CompatibleKey& x)const
> {
> return make_iterator(
> ordered_index_upper_bound(root(),header(),key,x,comp_));
> }
>
> template<typename CompatibleKey,typename CompatibleCompare>
> iterator upper_bound(
> const CompatibleKey& x,const CompatibleCompare& comp)const
> {
> return make_iterator(
> ordered_index_upper_bound(root(),header(),key,x,comp));
> }
>
> template<typename CompatibleKey>
> std::pair<iterator,iterator> equal_range(
> const CompatibleKey& x)const
> {
> std::pair<node_type*,node_type*> p=
> ordered_index_equal_range(root(),header(),key,x,comp_);
> return std::pair<iterator,iterator>(
> make_iterator(p.first),make_iterator(p.second));
> }
>
> template<typename CompatibleKey,typename CompatibleCompare>
> std::pair<iterator,iterator> equal_range(
> const CompatibleKey& x,const CompatibleCompare& comp)const
> {
> std::pair<node_type*,node_type*> p=
> ordered_index_equal_range(root(),header(),key,x,comp);
> return std::pair<iterator,iterator>(
> make_iterator(p.first),make_iterator(p.second));
> }
>
>
>
> template<typename LowerBounder,typename UpperBounder>
> std::pair<iterator,iterator>
> range(LowerBounder lower,UpperBounder upper)const
> {
> typedef typename mpl::if_<
> is_same<LowerBounder,unbounded_type>,
> typename mpl::if_<
> is_same<UpperBounder,unbounded_type>,
> both_unbounded_tag,
> lower_unbounded_tag
> >::type,
> typename mpl::if_<
> is_same<UpperBounder,unbounded_type>,
> upper_unbounded_tag,
> none_unbounded_tag
> >::type
> >::type dispatch;
>
> return range(lower,upper,dispatch());
> }
>
>protected:
> ordered_index(const ctor_args_list& args_list,const allocator_type& al):
> super(args_list.get_tail(),al),
> key(tuples::get<0>(args_list.get_head())),
> comp_(tuples::get<1>(args_list.get_head()))
> {
> empty_initialize();
> }
>
> ordered_index(
> const ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x):
> super(x),
>
>
>
>
>
> key(x.key),
> comp_(x.comp_)
> {
>
>
>
> }
>
> ~ordered_index()
> {
>
> }
>
>
>
>
>
>
> iterator make_iterator(node_type* node){return iterator(node);}
> const_iterator make_iterator(node_type* node)const
> {return const_iterator(node);}
>
>
> void copy_(
> const ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x,
> const copy_map_type& map)
> {
> if(!x.root()){
> empty_initialize();
> }
> else{
> header()->color()=x.header()->color();
>
> node_type* root_cpy=map.find(static_cast<final_node_type*>(x.root()));
> header()->parent()=root_cpy->impl();
>
> node_type* leftmost_cpy=map.find(
> static_cast<final_node_type*>(x.leftmost()));
> header()->left()=leftmost_cpy->impl();
>
> node_type* rightmost_cpy=map.find(
> static_cast<final_node_type*>(x.rightmost()));
> header()->right()=rightmost_cpy->impl();
>
> typedef typename copy_map_type::const_iterator copy_map_iterator;
> for(copy_map_iterator it=map.begin(),it_end=map.end();it!=it_end;++it){
> node_type* org=it->first;
> node_type* cpy=it->second;
>
> cpy->color()=org->color();
>
> node_impl_pointer parent_org=org->parent();
> if(parent_org==node_impl_pointer(0))cpy->parent()=node_impl_pointer(0);
> else{
> node_type* parent_cpy=map.find(
> static_cast<final_node_type*>(node_type::from_impl(parent_org)));
> cpy->parent()=parent_cpy->impl();
> if(parent_org->left()==org->impl()){
> parent_cpy->left()=cpy->impl();
> }
> else if(parent_org->right()==org->impl()){
>
> parent_cpy->right()=cpy->impl();
> }
> }
>
> if(org->left()==node_impl_pointer(0))
> cpy->left()=node_impl_pointer(0);
> if(org->right()==node_impl_pointer(0))
> cpy->right()=node_impl_pointer(0);
> }
> }
>
> super::copy_(x,map);
> }
>
> node_type* insert_(value_param_type v,node_type* x)
> {
> link_info inf;
> if(!link_point(key(v),inf,Category())){
> return node_type::from_impl(inf.pos);
> }
>
> node_type* res=static_cast<node_type*>(super::insert_(v,x));
> if(res==x){
> node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
> }
> return res;
> }
>
> node_type* insert_(value_param_type v,node_type* position,node_type* x)
> {
> link_info inf;
> if(!hinted_link_point(key(v),position,inf,Category())){
> return node_type::from_impl(inf.pos);
> }
>
> node_type* res=static_cast<node_type*>(super::insert_(v,position,x));
> if(res==x){
> node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
> }
> return res;
> }
>
> void erase_(node_type* x)
> {
> node_impl_type::rebalance_for_erase(
> x->impl(),header()->parent(),header()->left(),header()->right());
> super::erase_(x);
>
>
>
>
> }
>
> void delete_all_nodes_()
> {
> delete_all_nodes(root());
> }
>
> void clear_()
> {
> super::clear_();
> empty_initialize();
>
>
>
>
> }
>
> void swap_(ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x)
> {
> std::swap(key,x.key);
> std::swap(comp_,x.comp_);
>
>
>
>
>
> super::swap_(x);
> }
>
> bool replace_(value_param_type v,node_type* x)
> {
> if(in_place(v,x,Category())){
> return super::replace_(v,x);
> }
>
> node_type* next=x;
> node_type::increment(next);
>
> node_impl_type::rebalance_for_erase(
> x->impl(),header()->parent(),header()->left(),header()->right());
>
> { try{
> link_info inf;
> if(link_point(key(v),inf,Category())&&super::replace_(v,x)){
> node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
> return true;
> }
> node_impl_type::restore(x->impl(),next->impl(),header()->impl());
> return false;
> }
> catch(...){
> node_impl_type::restore(x->impl(),next->impl(),header()->impl());
> throw;;
> }
> }
> }
>
> bool modify_(node_type* x)
> {
> bool b;
> { try{
> b=in_place(x->value(),x,Category());
> }
> catch(...){
> erase_(x);
> throw;;
> }
> }
> if(!b){
> node_impl_type::rebalance_for_erase(
> x->impl(),header()->parent(),header()->left(),header()->right());
> { try{
> link_info inf;
> if(!link_point(key(x->value()),inf,Category())){
> super::erase_(x);
>
>
>
>
> return false;
> }
> node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
> }
> catch(...){
> super::erase_(x);
>
>
>
>
>
> throw;;
> }
> }
> }
>
> { try{
> if(!super::modify_(x)){
> node_impl_type::rebalance_for_erase(
> x->impl(),header()->parent(),header()->left(),header()->right());
>
>
>
>
>
> return false;
> }
> else return true;
> }
> catch(...){
> node_impl_type::rebalance_for_erase(
> x->impl(),header()->parent(),header()->left(),header()->right());
>
>
>
>
>
> throw;;
> }
> }
> }
>
> bool modify_rollback_(node_type* x)
> {
> if(in_place(x->value(),x,Category())){
> return super::modify_rollback_(x);
> }
>
> node_type* next=x;
> node_type::increment(next);
>
> node_impl_type::rebalance_for_erase(
> x->impl(),header()->parent(),header()->left(),header()->right());
>
> { try{
> link_info inf;
> if(link_point(key(x->value()),inf,Category())&&
> super::modify_rollback_(x)){
> node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
> return true;
> }
> node_impl_type::restore(x->impl(),next->impl(),header()->impl());
> return false;
> }
> catch(...){
> node_impl_type::restore(x->impl(),next->impl(),header()->impl());
> throw;;
> }
> }
> }
>
>
>
>
> template<typename Archive>
> void save_(
> Archive& ar,const unsigned int version,const index_saver_type& sm)const
> {
> save_(ar,version,sm,Category());
> }
>
> template<typename Archive>
> void load_(Archive& ar,const unsigned int version,const index_loader_type& lm)
> {
> load_(ar,version,lm,Category());
> }
># 879 "/usr/include/boost/multi_index/ordered_index.hpp" 3 4
>private:
> node_type* header()const{return this->final_header();}
> node_type* root()const{return node_type::from_impl(header()->parent());}
> node_type* leftmost()const{return node_type::from_impl(header()->left());}
> node_type* rightmost()const{return node_type::from_impl(header()->right());}
>
> void empty_initialize()
> {
> header()->color()=red;
>
>
> header()->parent()=node_impl_pointer(0);
> header()->left()=header()->impl();
> header()->right()=header()->impl();
> }
>
> struct link_info
> {
> link_info():side(to_left){}
>
> ordered_index_side side;
> node_impl_pointer pos;
> };
>
> bool link_point(key_param_type k,link_info& inf,ordered_unique_tag)
> {
> node_type* y=header();
> node_type* x=root();
> bool c=true;
> while(x){
> y=x;
> c=comp_(k,key(x->value()));
> x=node_type::from_impl(c?x->left():x->right());
> }
> node_type* yy=y;
> if(c){
> if(yy==leftmost()){
> inf.side=to_left;
> inf.pos=y->impl();
> return true;
> }
> else node_type::decrement(yy);
> }
>
> if(comp_(key(yy->value()),k)){
> inf.side=c?to_left:to_right;
> inf.pos=y->impl();
> return true;
> }
> else{
> inf.pos=yy->impl();
> return false;
> }
> }
>
> bool link_point(key_param_type k,link_info& inf,ordered_non_unique_tag)
> {
> node_type* y=header();
> node_type* x=root();
> bool c=true;
> while (x){
> y=x;
> c=comp_(k,key(x->value()));
> x=node_type::from_impl(c?x->left():x->right());
> }
> inf.side=c?to_left:to_right;
> inf.pos=y->impl();
> return true;
> }
>
> bool lower_link_point(key_param_type k,link_info& inf,ordered_non_unique_tag)
> {
> node_type* y=header();
> node_type* x=root();
> bool c=false;
> while (x){
> y=x;
> c=comp_(key(x->value()),k);
> x=node_type::from_impl(c?x->right():x->left());
> }
> inf.side=c?to_right:to_left;
> inf.pos=y->impl();
> return true;
> }
>
> bool hinted_link_point(
> key_param_type k,node_type* position,link_info& inf,ordered_unique_tag)
> {
> if(position->impl()==header()->left()){
> if(size()>0&&comp_(k,key(position->value()))){
> inf.side=to_left;
> inf.pos=position->impl();
> return true;
> }
> else return link_point(k,inf,ordered_unique_tag());
> }
> else if(position==header()){
> if(comp_(key(rightmost()->value()),k)){
> inf.side=to_right;
> inf.pos=rightmost()->impl();
> return true;
> }
> else return link_point(k,inf,ordered_unique_tag());
> }
> else{
> node_type* before=position;
> node_type::decrement(before);
> if(comp_(key(before->value()),k)&&comp_(k,key(position->value()))){
> if(before->right()==node_impl_pointer(0)){
> inf.side=to_right;
> inf.pos=before->impl();
> return true;
> }
> else{
> inf.side=to_left;
> inf.pos=position->impl();
> return true;
> }
> }
> else return link_point(k,inf,ordered_unique_tag());
> }
> }
>
> bool hinted_link_point(
> key_param_type k,node_type* position,link_info& inf,ordered_non_unique_tag)
> {
> if(position->impl()==header()->left()){
> if(size()>0&&!comp_(key(position->value()),k)){
> inf.side=to_left;
> inf.pos=position->impl();
> return true;
> }
> else return lower_link_point(k,inf,ordered_non_unique_tag());
> }
> else if(position==header()){
> if(!comp_(k,key(rightmost()->value()))){
> inf.side=to_right;
> inf.pos=rightmost()->impl();
> return true;
> }
> else return link_point(k,inf,ordered_non_unique_tag());
> }
> else{
> node_type* before=position;
> node_type::decrement(before);
> if(!comp_(k,key(before->value()))){
> if(!comp_(key(position->value()),k)){
> if(before->right()==node_impl_pointer(0)){
> inf.side=to_right;
> inf.pos=before->impl();
> return true;
> }
> else{
> inf.side=to_left;
> inf.pos=position->impl();
> return true;
> }
> }
> else return lower_link_point(k,inf,ordered_non_unique_tag());
> }
> else return link_point(k,inf,ordered_non_unique_tag());
> }
> }
>
> void delete_all_nodes(node_type* x)
> {
> if(!x)return;
>
> delete_all_nodes(node_type::from_impl(x->left()));
> delete_all_nodes(node_type::from_impl(x->right()));
> this->final_delete_node_(static_cast<final_node_type*>(x));
> }
>
> bool in_place(value_param_type v,node_type* x,ordered_unique_tag)
> {
> node_type* y;
> if(x!=leftmost()){
> y=x;
> node_type::decrement(y);
> if(!comp_(key(y->value()),key(v)))return false;
> }
>
> y=x;
> node_type::increment(y);
> return y==header()||comp_(key(v),key(y->value()));
> }
>
> bool in_place(value_param_type v,node_type* x,ordered_non_unique_tag)
> {
> node_type* y;
> if(x!=leftmost()){
> y=x;
> node_type::decrement(y);
> if(comp_(key(v),key(y->value())))return false;
> }
>
> y=x;
> node_type::increment(y);
> return y==header()||!comp_(key(y->value()),key(v));
> }
># 1088 "/usr/include/boost/multi_index/ordered_index.hpp" 3 4
> template<typename LowerBounder,typename UpperBounder>
> std::pair<iterator,iterator>
> range(LowerBounder lower,UpperBounder upper,none_unbounded_tag)const
> {
> node_type* y=header();
> node_type* z=root();
>
> while(z){
> if(!lower(key(z->value()))){
> z=node_type::from_impl(z->right());
> }
> else if(!upper(key(z->value()))){
> y=z;
> z=node_type::from_impl(z->left());
> }
> else{
> return std::pair<iterator,iterator>(
> make_iterator(
> lower_range(node_type::from_impl(z->left()),z,lower)),
> make_iterator(
> upper_range(node_type::from_impl(z->right()),y,upper)));
> }
> }
>
> return std::pair<iterator,iterator>(make_iterator(y),make_iterator(y));
> }
>
> template<typename LowerBounder,typename UpperBounder>
> std::pair<iterator,iterator>
> range(LowerBounder,UpperBounder upper,lower_unbounded_tag)const
> {
> return std::pair<iterator,iterator>(
> begin(),
> make_iterator(upper_range(root(),header(),upper)));
> }
>
> template<typename LowerBounder,typename UpperBounder>
> std::pair<iterator,iterator>
> range(LowerBounder lower,UpperBounder,upper_unbounded_tag)const
> {
> return std::pair<iterator,iterator>(
> make_iterator(lower_range(root(),header(),lower)),
> end());
> }
>
> template<typename LowerBounder,typename UpperBounder>
> std::pair<iterator,iterator>
> range(LowerBounder,UpperBounder,both_unbounded_tag)const
> {
> return std::pair<iterator,iterator>(begin(),end());
> }
>
> template<typename LowerBounder>
> node_type * lower_range(node_type* top,node_type* y,LowerBounder lower)const
> {
> while(top){
> if(lower(key(top->value()))){
> y=top;
> top=node_type::from_impl(top->left());
> }
> else top=node_type::from_impl(top->right());
> }
>
> return y;
> }
>
> template<typename UpperBounder>
> node_type * upper_range(node_type* top,node_type* y,UpperBounder upper)const
> {
> while(top){
> if(!upper(key(top->value()))){
> y=top;
> top=node_type::from_impl(top->left());
> }
> else top=node_type::from_impl(top->right());
> }
>
> return y;
> }
>
>
> template<typename Archive>
> void save_(
> Archive& ar,const unsigned int version,const index_saver_type& sm,
> ordered_unique_tag)const
> {
> super::save_(ar,version,sm);
> }
>
> template<typename Archive>
> void load_(
> Archive& ar,const unsigned int version,const index_loader_type& lm,
> ordered_unique_tag)
> {
> super::load_(ar,version,lm);
> }
>
> template<typename Archive>
> void save_(
> Archive& ar,const unsigned int version,const index_saver_type& sm,
> ordered_non_unique_tag)const
> {
> typedef duplicates_iterator<node_type,value_compare> dup_iterator;
>
> sm.save(
> dup_iterator(begin().get_node(),end().get_node(),value_comp()),
> dup_iterator(end().get_node(),value_comp()),
> ar,version);
> super::save_(ar,version,sm);
> }
>
> template<typename Archive>
> void load_(
> Archive& ar,const unsigned int version,const index_loader_type& lm,
> ordered_non_unique_tag)
> {
> lm.load(
> ::boost::bind(&ordered_index::rearranger,this,_1,_2),
> ar,version);
> super::load_(ar,version,lm);
> }
>
> void rearranger(node_type* position,node_type *x)
> {
> if(!position||comp_(key(position->value()),key(x->value()))){
> position=lower_bound(key(x->value())).get_node();
> }
> else if(comp_(key(x->value()),key(position->value()))){
>
> throw_exception(
> archive::archive_exception(
> archive::archive_exception::other_exception));
> }
> else node_type::increment(position);
>
> if(position!=x){
> node_impl_type::rebalance_for_erase(
> x->impl(),header()->parent(),header()->left(),header()->right());
> node_impl_type::restore(
> x->impl(),position->impl(),header()->impl());
> }
> }
>
>
> key_from_value key;
> key_compare comp_;
>
>
>
>
>
>};
>
>
>
>template<
> typename KeyFromValue1,typename Compare1,
> typename SuperMeta1,typename TagList1,typename Category1,
> typename KeyFromValue2,typename Compare2,
> typename SuperMeta2,typename TagList2,typename Category2
>>
>bool operator==(
> const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
> const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
>{
> return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
>}
>
>template<
> typename KeyFromValue1,typename Compare1,
> typename SuperMeta1,typename TagList1,typename Category1,
> typename KeyFromValue2,typename Compare2,
> typename SuperMeta2,typename TagList2,typename Category2
>>
>bool operator<(
> const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
> const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
>{
> return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
>}
>
>template<
> typename KeyFromValue1,typename Compare1,
> typename SuperMeta1,typename TagList1,typename Category1,
> typename KeyFromValue2,typename Compare2,
> typename SuperMeta2,typename TagList2,typename Category2
>>
>bool operator!=(
> const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
> const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
>{
> return !(x==y);
>}
>
>template<
> typename KeyFromValue1,typename Compare1,
> typename SuperMeta1,typename TagList1,typename Category1,
> typename KeyFromValue2,typename Compare2,
> typename SuperMeta2,typename TagList2,typename Category2
>>
>bool operator>(
> const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
> const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
>{
> return y<x;
>}
>
>template<
> typename KeyFromValue1,typename Compare1,
> typename SuperMeta1,typename TagList1,typename Category1,
> typename KeyFromValue2,typename Compare2,
> typename SuperMeta2,typename TagList2,typename Category2
>>
>bool operator>=(
> const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
> const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
>{
> return !(x<y);
>}
>
>template<
> typename KeyFromValue1,typename Compare1,
> typename SuperMeta1,typename TagList1,typename Category1,
> typename KeyFromValue2,typename Compare2,
> typename SuperMeta2,typename TagList2,typename Category2
>>
>bool operator<=(
> const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
> const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
>{
> return !(x>y);
>}
>
>
>
>template<
> typename KeyFromValue,typename Compare,
> typename SuperMeta,typename TagList,typename Category
>>
>void swap(
> ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x,
> ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& y)
>{
> x.swap(y);
>}
>
>}
>
>
>
>template<typename Arg1,typename Arg2,typename Arg3>
>struct ordered_unique
>{
> typedef typename detail::ordered_index_args<
> Arg1,Arg2,Arg3> index_args;
> typedef typename index_args::tag_list_type::type tag_list_type;
> typedef typename index_args::key_from_value_type key_from_value_type;
> typedef typename index_args::compare_type compare_type;
>
> template<typename Super>
> struct node_class
> {
> typedef detail::ordered_index_node<Super> type;
> };
>
> template<typename SuperMeta>
> struct index_class
> {
> typedef detail::ordered_index<
> key_from_value_type,compare_type,
> SuperMeta,tag_list_type,detail::ordered_unique_tag> type;
> };
>};
>
>template<typename Arg1,typename Arg2,typename Arg3>
>struct ordered_non_unique
>{
> typedef detail::ordered_index_args<
> Arg1,Arg2,Arg3> index_args;
> typedef typename index_args::tag_list_type::type tag_list_type;
> typedef typename index_args::key_from_value_type key_from_value_type;
> typedef typename index_args::compare_type compare_type;
>
> template<typename Super>
> struct node_class
> {
> typedef detail::ordered_index_node<Super> type;
> };
>
> template<typename SuperMeta>
> struct index_class
> {
> typedef detail::ordered_index<
> key_from_value_type,compare_type,
> SuperMeta,tag_list_type,detail::ordered_non_unique_tag> type;
> };
>};
>
>}
>
>}
>
>
>
>template<
> typename KeyFromValue,typename Compare,
> typename SuperMeta,typename TagList,typename Category
>>
>inline boost::mpl::true_* boost_foreach_is_noncopyable(
> boost::multi_index::detail::ordered_index<
> KeyFromValue,Compare,SuperMeta,TagList,Category>*&,
> boost::foreach::tag)
>{
> return 0;
>}
># 25 "/usr/include/boost/property_tree/ptree.hpp" 2 3 4
># 1 "/usr/include/boost/multi_index/member.hpp" 1 3 4
># 20 "/usr/include/boost/multi_index/member.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 21 "/usr/include/boost/multi_index/member.hpp" 2 3 4
>
>
>
>
>
>namespace boost{
>
>template<class T> class reference_wrapper;
>
>namespace multi_index{
>
>namespace detail{
># 54 "/usr/include/boost/multi_index/member.hpp" 3 4
>template<class Class,typename Type,Type Class::*PtrToMember>
>struct const_member_base
>{
> typedef Type result_type;
>
> template<typename ChainedPtr>
>
>
> typename disable_if<
> is_convertible<const ChainedPtr&,const Class&>,Type&>::type
>
>
>
>
> operator()(const ChainedPtr& x)const
> {
> return operator()(*x);
> }
>
> Type& operator()(const Class& x)const
> {
> return x.*PtrToMember;
> }
>
> Type& operator()(const reference_wrapper<const Class>& x)const
> {
> return operator()(x.get());
> }
>
> Type& operator()(const reference_wrapper<Class>& x,int=0)const
> {
> return operator()(x.get());
> }
>};
>
>template<class Class,typename Type,Type Class::*PtrToMember>
>struct non_const_member_base
>{
> typedef Type result_type;
>
> template<typename ChainedPtr>
>
>
> typename disable_if<
> is_convertible<const ChainedPtr&,const Class&>,Type&>::type
>
>
>
>
> operator()(const ChainedPtr& x)const
> {
> return operator()(*x);
> }
>
> const Type& operator()(const Class& x,int=0)const
> {
> return x.*PtrToMember;
> }
>
> Type& operator()(Class& x)const
> {
> return x.*PtrToMember;
> }
>
> const Type& operator()(const reference_wrapper<const Class>& x,int=0)const
> {
> return operator()(x.get());
> }
>
> Type& operator()(const reference_wrapper<Class>& x)const
> {
> return operator()(x.get());
> }
>};
>
>}
>
>template<class Class,typename Type,Type Class::*PtrToMember>
>struct member:
> mpl::if_c<
> is_const<Type>::value,
> detail::const_member_base<Class,Type,PtrToMember>,
> detail::non_const_member_base<Class,Type,PtrToMember>
> >::type
>{
>};
>
>namespace detail{
># 157 "/usr/include/boost/multi_index/member.hpp" 3 4
>template<class Class,typename Type,std::size_t OffsetOfMember>
>struct const_member_offset_base
>{
> typedef Type result_type;
>
> template<typename ChainedPtr>
>
>
> typename disable_if<
> is_convertible<const ChainedPtr&,const Class&>,Type&>::type
>
>
>
>
> operator()(const ChainedPtr& x)const
> {
> return operator()(*x);
> }
>
> Type& operator()(const Class& x)const
> {
> return *static_cast<const Type*>(
> static_cast<const void*>(
> static_cast<const char*>(
> static_cast<const void *>(&x))+OffsetOfMember));
> }
>
> Type& operator()(const reference_wrapper<const Class>& x)const
> {
> return operator()(x.get());
> }
>
> Type& operator()(const reference_wrapper<Class>& x,int=0)const
> {
> return operator()(x.get());
> }
>};
>
>template<class Class,typename Type,std::size_t OffsetOfMember>
>struct non_const_member_offset_base
>{
> typedef Type result_type;
>
> template<typename ChainedPtr>
>
>
> typename disable_if<
> is_convertible<const ChainedPtr&,const Class&>,Type&>::type
>
>
>
>
> operator()(const ChainedPtr& x)const
> {
> return operator()(*x);
> }
>
> const Type& operator()(const Class& x,int=0)const
> {
> return *static_cast<const Type*>(
> static_cast<const void*>(
> static_cast<const char*>(
> static_cast<const void *>(&x))+OffsetOfMember));
> }
>
> Type& operator()(Class& x)const
> {
> return *static_cast<Type*>(
> static_cast<void*>(
> static_cast<char*>(static_cast<void *>(&x))+OffsetOfMember));
> }
>
> const Type& operator()(const reference_wrapper<const Class>& x,int=0)const
> {
> return operator()(x.get());
> }
>
> Type& operator()(const reference_wrapper<Class>& x)const
> {
> return operator()(x.get());
> }
>};
>
>}
>
>template<class Class,typename Type,std::size_t OffsetOfMember>
>struct member_offset:
> mpl::if_c<
> is_const<Type>::value,
> detail::const_member_offset_base<Class,Type,OffsetOfMember>,
> detail::non_const_member_offset_base<Class,Type,OffsetOfMember>
> >::type
>{
>};
># 265 "/usr/include/boost/multi_index/member.hpp" 3 4
>}
>
>}
># 26 "/usr/include/boost/property_tree/ptree.hpp" 2 3 4
>
>
>
>
>
>namespace boost { namespace property_tree
>{
># 47 "/usr/include/boost/property_tree/ptree.hpp" 3 4
> template<class Key, class Data, class KeyCompare>
> class basic_ptree
> {
># 58 "/usr/include/boost/property_tree/ptree.hpp" 3 4
> typedef basic_ptree<Key, Data, KeyCompare> self_type;
>
> public:
>
> typedef Key key_type;
> typedef Data data_type;
> typedef KeyCompare key_compare;
>
>
> typedef std::pair<const Key, self_type> value_type;
> typedef std::size_t size_type;
>
>
>
> class iterator;
> class const_iterator;
> class reverse_iterator;
> class const_reverse_iterator;
>
>
> class assoc_iterator;
> class const_assoc_iterator;
>
>
> typedef typename path_of<Key>::type path_type;
>
>
>
>
>
> basic_ptree();
>
> explicit basic_ptree(const data_type &data);
> basic_ptree(const self_type &rhs);
> ~basic_ptree();
>
> self_type &operator =(const self_type &rhs);
>
>
>
>
> void swap(self_type &rhs);
>
>
>
>
> size_type size() const;
> size_type max_size() const;
>
> bool empty() const;
>
> iterator begin();
> const_iterator begin() const;
> iterator end();
> const_iterator end() const;
> reverse_iterator rbegin();
> const_reverse_iterator rbegin() const;
> reverse_iterator rend();
> const_reverse_iterator rend() const;
>
> value_type &front();
> const value_type &front() const;
> value_type &back();
> const value_type &back() const;
>
>
>
>
>
> iterator insert(iterator where, const value_type &value);
>
>
>
>
>
>
> template<class It> void insert(iterator where, It first, It last);
>
>
>
>
>
>
> iterator erase(iterator where);
>
>
>
>
>
>
> iterator erase(iterator first, iterator last);
>
>
> iterator push_front(const value_type &value);
>
>
> iterator push_back(const value_type &value);
>
>
> void pop_front();
>
>
> void pop_back();
>
>
> void reverse();
>
>
>
>
> template<class Compare> void sort(Compare comp);
>
>
> void sort();
>
>
>
>
>
>
>
> bool operator ==(const self_type &rhs) const;
> bool operator !=(const self_type &rhs) const;
>
>
>
>
> assoc_iterator ordered_begin();
>
> const_assoc_iterator ordered_begin() const;
>
>
>
>
> assoc_iterator not_found();
>
>
>
> const_assoc_iterator not_found() const;
>
>
>
>
>
> assoc_iterator find(const key_type &key);
>
>
>
>
>
> const_assoc_iterator find(const key_type &key) const;
>
>
> std::pair<assoc_iterator, assoc_iterator>
> equal_range(const key_type &key);
>
>
> std::pair<const_assoc_iterator, const_assoc_iterator>
> equal_range(const key_type &key) const;
>
>
> size_type count(const key_type &key) const;
>
>
>
> size_type erase(const key_type &key);
>
>
>
>
>
> iterator to_iterator(assoc_iterator it);
>
>
>
>
>
> const_iterator to_iterator(const_assoc_iterator it) const;
>
>
>
>
> data_type &data();
>
>
> const data_type &data() const;
>
>
> void clear();
># 261 "/usr/include/boost/property_tree/ptree.hpp" 3 4
> self_type &get_child(const path_type &path);
>
>
> const self_type &get_child(const path_type &path) const;
>
>
> self_type &get_child(const path_type &path, self_type &default_value);
>
>
> const self_type &get_child(const path_type &path,
> const self_type &default_value) const;
>
>
> optional<self_type &> get_child_optional(const path_type &path);
>
>
> optional<const self_type &>
> get_child_optional(const path_type &path) const;
># 288 "/usr/include/boost/property_tree/ptree.hpp" 3 4
> self_type &put_child(const path_type &path, const self_type &value);
># 298 "/usr/include/boost/property_tree/ptree.hpp" 3 4
> self_type &add_child(const path_type &path, const self_type &value);
>
>
>
>
>
> template<class Type, class Translator>
> typename boost::enable_if<detail::is_translator<Translator>, Type>::type
> get_value(Translator tr) const;
>
>
>
>
>
> template<class Type>
> Type get_value() const;
>
>
>
>
>
> template<class Type, class Translator>
> Type get_value(const Type &default_value, Translator tr) const;
>
>
> template <class Ch, class Translator>
> typename boost::enable_if<
> detail::is_character<Ch>,
> std::basic_string<Ch>
> >::type
> get_value(const Ch *default_value, Translator tr) const;
>
>
>
>
>
> template<class Type>
> typename boost::disable_if<detail::is_translator<Type>, Type>::type
> get_value(const Type &default_value) const;
>
>
> template <class Ch>
> typename boost::enable_if<
> detail::is_character<Ch>,
> std::basic_string<Ch>
> >::type
> get_value(const Ch *default_value) const;
>
>
>
>
>
> template<class Type, class Translator>
> optional<Type> get_value_optional(Translator tr) const;
>
>
>
>
>
> template<class Type>
> optional<Type> get_value_optional() const;
>
>
>
>
>
> template<class Type, class Translator>
> void put_value(const Type &value, Translator tr);
>
>
>
>
>
> template<class Type>
> void put_value(const Type &value);
>
>
> template<class Type, class Translator>
> typename boost::enable_if<detail::is_translator<Translator>, Type>::type
> get(const path_type &path, Translator tr) const;
>
>
> template<class Type>
> Type get(const path_type &path) const;
>
>
>
>
>
>
> template<class Type, class Translator>
> Type get(const path_type &path,
> const Type &default_value,
> Translator tr) const;
>
>
> template <class Ch, class Translator>
> typename boost::enable_if<
> detail::is_character<Ch>,
> std::basic_string<Ch>
> >::type
> get(const path_type &path, const Ch *default_value, Translator tr)const;
>
>
>
>
>
>
> template<class Type>
> typename boost::disable_if<detail::is_translator<Type>, Type>::type
> get(const path_type &path, const Type &default_value) const;
>
>
> template <class Ch>
> typename boost::enable_if<
> detail::is_character<Ch>,
> std::basic_string<Ch>
> >::type
> get(const path_type &path, const Ch *default_value) const;
># 426 "/usr/include/boost/property_tree/ptree.hpp" 3 4
> template<class Type, class Translator>
> optional<Type> get_optional(const path_type &path, Translator tr) const;
># 437 "/usr/include/boost/property_tree/ptree.hpp" 3 4
> template<class Type>
> optional<Type> get_optional(const path_type &path) const;
>
>
>
>
>
>
>
> template<class Type, class Translator>
> self_type &put(const path_type &path, const Type &value, Translator tr);
>
>
>
>
>
>
>
> template<class Type>
> self_type &put(const path_type &path, const Type &value);
># 470 "/usr/include/boost/property_tree/ptree.hpp" 3 4
> template<class Type, class Translator>
> self_type &add(const path_type &path,
> const Type &value,
> Translator tr);
># 486 "/usr/include/boost/property_tree/ptree.hpp" 3 4
> template<class Type>
> self_type &add(const path_type &path, const Type &value);
>
> private:
>
> data_type m_data;
>
>
> void* m_children;
>
>
>
> self_type* walk_path(path_type& p) const;
>
>
>
>
> self_type& force_path(path_type& p);
>
>
> struct subs;
> friend struct subs;
> friend class iterator;
> friend class const_iterator;
> friend class reverse_iterator;
> friend class const_reverse_iterator;
> };
>
>}}
>
># 1 "/usr/include/boost/property_tree/detail/ptree_implementation.hpp" 1 3 4
># 16 "/usr/include/boost/property_tree/detail/ptree_implementation.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 17 "/usr/include/boost/property_tree/detail/ptree_implementation.hpp" 2 3 4
># 27 "/usr/include/boost/property_tree/detail/ptree_implementation.hpp" 3 4
>namespace boost { namespace property_tree
>{
> template <class K, class D, class C>
> struct basic_ptree<K, D, C>::subs
> {
> struct by_name {};
>
>
>
>
>
>
>
> typedef multi_index_container<value_type,
> multi_index::indexed_by<
> multi_index::sequenced<>,
> multi_index::ordered_non_unique<multi_index::tag<by_name>,
>
>
>
>
> multi_index::member<value_type, const key_type,
> &value_type::first>,
>
> key_compare
> >
> >
> > base_container;
>
>
> typedef typename base_container::template index<by_name>::type
> by_name_index;
>
>
> static base_container& ch(self_type *s) {
> return *static_cast<base_container*>(s->m_children);
> }
> static const base_container& ch(const self_type *s) {
> return *static_cast<const base_container*>(s->m_children);
> }
> static by_name_index& assoc(self_type *s) {
> return ch(s).template get<by_name>();
> }
> static const by_name_index& assoc(const self_type *s) {
> return ch(s).template get<by_name>();
> }
> };
> template <class K, class D, class C>
> class basic_ptree<K, D, C>::iterator : public boost::iterator_adaptor<
> iterator, typename subs::base_container::iterator, value_type>
> {
> friend class boost::iterator_core_access;
> typedef boost::iterator_adaptor<
> iterator, typename subs::base_container::iterator, value_type>
> baset;
> public:
> typedef typename baset::reference reference;
> iterator() {}
> explicit iterator(typename iterator::base_type b)
> : iterator::iterator_adaptor_(b)
> {}
> reference dereference() const
> {
>
>
>
>
> return const_cast<reference>(*this->base_reference());
> }
> };
> template <class K, class D, class C>
> class basic_ptree<K, D, C>::const_iterator : public boost::iterator_adaptor<
> const_iterator, typename subs::base_container::const_iterator>
> {
> public:
> const_iterator() {}
> explicit const_iterator(typename const_iterator::base_type b)
> : const_iterator::iterator_adaptor_(b)
> {}
> const_iterator(iterator b)
> : const_iterator::iterator_adaptor_(b.base())
> {}
> };
> template <class K, class D, class C>
> class basic_ptree<K, D, C>::reverse_iterator
> : public boost::reverse_iterator<iterator>
> {
> public:
> reverse_iterator() {}
> explicit reverse_iterator(iterator b)
> : boost::reverse_iterator<iterator>(b)
> {}
> };
> template <class K, class D, class C>
> class basic_ptree<K, D, C>::const_reverse_iterator
> : public boost::reverse_iterator<const_iterator>
> {
> public:
> const_reverse_iterator() {}
> explicit const_reverse_iterator(const_iterator b)
> : boost::reverse_iterator<const_iterator>(b)
> {}
> const_reverse_iterator(
> typename basic_ptree<K, D, C>::reverse_iterator b)
> : boost::reverse_iterator<const_iterator>(b)
> {}
> };
> template <class K, class D, class C>
> class basic_ptree<K, D, C>::assoc_iterator
> : public boost::iterator_adaptor<assoc_iterator,
> typename subs::by_name_index::iterator,
> value_type>
> {
> friend class boost::iterator_core_access;
> typedef boost::iterator_adaptor<assoc_iterator,
> typename subs::by_name_index::iterator,
> value_type>
> baset;
> public:
> typedef typename baset::reference reference;
> assoc_iterator() {}
> explicit assoc_iterator(typename assoc_iterator::base_type b)
> : assoc_iterator::iterator_adaptor_(b)
> {}
> reference dereference() const
> {
> return const_cast<reference>(*this->base_reference());
> }
> };
> template <class K, class D, class C>
> class basic_ptree<K, D, C>::const_assoc_iterator
> : public boost::iterator_adaptor<const_assoc_iterator,
> typename subs::by_name_index::const_iterator>
> {
> public:
> const_assoc_iterator() {}
> explicit const_assoc_iterator(
> typename const_assoc_iterator::base_type b)
> : const_assoc_iterator::iterator_adaptor_(b)
> {}
> const_assoc_iterator(assoc_iterator b)
> : const_assoc_iterator::iterator_adaptor_(b.base())
> {}
> };
>
>
>
>
>
>
>
> template<class K, class D, class C> inline
> basic_ptree<K, D, C>::basic_ptree()
> : m_children(new typename subs::base_container)
> {
> }
>
> template<class K, class D, class C> inline
> basic_ptree<K, D, C>::basic_ptree(const data_type &d)
> : m_data(d), m_children(new typename subs::base_container)
> {
> }
>
> template<class K, class D, class C> inline
> basic_ptree<K, D, C>::basic_ptree(const basic_ptree<K, D, C> &rhs)
> : m_data(rhs.m_data),
> m_children(new typename subs::base_container(subs::ch(&rhs)))
> {
> }
>
> template<class K, class D, class C>
> basic_ptree<K, D, C> &
> basic_ptree<K, D, C>::operator =(const basic_ptree<K, D, C> &rhs)
> {
> self_type(rhs).swap(*this);
> return *this;
> }
>
> template<class K, class D, class C>
> basic_ptree<K, D, C>::~basic_ptree()
> {
> delete &subs::ch(this);
> }
>
> template<class K, class D, class C> inline
> void basic_ptree<K, D, C>::swap(basic_ptree<K, D, C> &rhs)
> {
> boost::swap(m_data, rhs.m_data);
>
> std::swap(m_children, rhs.m_children);
> }
>
>
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::size_type
> basic_ptree<K, D, C>::size() const
> {
> return subs::ch(this).size();
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::size_type
> basic_ptree<K, D, C>::max_size() const
> {
> return subs::ch(this).max_size();
> }
>
> template<class K, class D, class C> inline
> bool basic_ptree<K, D, C>::empty() const
> {
> return subs::ch(this).empty();
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::iterator
> basic_ptree<K, D, C>::begin()
> {
> return iterator(subs::ch(this).begin());
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::const_iterator
> basic_ptree<K, D, C>::begin() const
> {
> return const_iterator(subs::ch(this).begin());
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::iterator
> basic_ptree<K, D, C>::end()
> {
> return iterator(subs::ch(this).end());
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::const_iterator
> basic_ptree<K, D, C>::end() const
> {
> return const_iterator(subs::ch(this).end());
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::reverse_iterator
> basic_ptree<K, D, C>::rbegin()
> {
> return reverse_iterator(this->end());
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::const_reverse_iterator
> basic_ptree<K, D, C>::rbegin() const
> {
> return const_reverse_iterator(this->end());
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::reverse_iterator
> basic_ptree<K, D, C>::rend()
> {
> return reverse_iterator(this->begin());
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::const_reverse_iterator
> basic_ptree<K, D, C>::rend() const
> {
> return const_reverse_iterator(this->begin());
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::value_type &
> basic_ptree<K, D, C>::front()
> {
> return const_cast<value_type&>(subs::ch(this).front());
> }
>
> template<class K, class D, class C> inline
> const typename basic_ptree<K, D, C>::value_type &
> basic_ptree<K, D, C>::front() const
> {
> return subs::ch(this).front();
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::value_type &
> basic_ptree<K, D, C>::back()
> {
> return const_cast<value_type&>(subs::ch(this).back());
> }
>
> template<class K, class D, class C> inline
> const typename basic_ptree<K, D, C>::value_type &
> basic_ptree<K, D, C>::back() const
> {
> return subs::ch(this).back();
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::iterator
> basic_ptree<K, D, C>::insert(iterator where, const value_type &value)
> {
> return iterator(subs::ch(this).insert(where.base(), value).first);
> }
>
> template<class K, class D, class C>
> template<class It> inline
> void basic_ptree<K, D, C>::insert(iterator where, It first, It last)
> {
> subs::ch(this).insert(where.base(), first, last);
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::iterator
> basic_ptree<K, D, C>::erase(iterator where)
> {
> return iterator(subs::ch(this).erase(where.base()));
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::iterator
> basic_ptree<K, D, C>::erase(iterator first, iterator last)
> {
> return iterator(subs::ch(this).erase(first.base(), last.base()));
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::iterator
> basic_ptree<K, D, C>::push_front(const value_type &value)
> {
> return iterator(subs::ch(this).push_front(value).first);
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::iterator
> basic_ptree<K, D, C>::push_back(const value_type &value)
> {
> return iterator(subs::ch(this).push_back(value).first);
> }
>
> template<class K, class D, class C> inline
> void basic_ptree<K, D, C>::pop_front()
> {
> subs::ch(this).pop_front();
> }
>
> template<class K, class D, class C> inline
> void basic_ptree<K, D, C>::pop_back()
> {
> subs::ch(this).pop_back();
> }
>
> template<class K, class D, class C> inline
> void basic_ptree<K, D, C>::reverse()
> {
> subs::ch(this).reverse();
> }
>
> namespace impl
> {
> struct by_first
> {
> template <typename P>
> bool operator ()(const P& lhs, const P& rhs) const {
> return lhs.first < rhs.first;
> }
> };
> }
>
> template<class K, class D, class C> inline
> void basic_ptree<K, D, C>::sort()
> {
> sort(impl::by_first());
> }
>
> template<class K, class D, class C>
> template<class Compare> inline
> void basic_ptree<K, D, C>::sort(Compare comp)
> {
> subs::ch(this).sort(comp);
> }
>
>
>
> template<class K, class D, class C> inline
> bool basic_ptree<K, D, C>::operator ==(
> const basic_ptree<K, D, C> &rhs) const
> {
>
> return size() == rhs.size() && data() == rhs.data() &&
> subs::ch(this) == subs::ch(&rhs);
> }
>
> template<class K, class D, class C> inline
> bool basic_ptree<K, D, C>::operator !=(
> const basic_ptree<K, D, C> &rhs) const
> {
> return !(*this == rhs);
> }
>
>
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::assoc_iterator
> basic_ptree<K, D, C>::ordered_begin()
> {
> return assoc_iterator(subs::assoc(this).begin());
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::const_assoc_iterator
> basic_ptree<K, D, C>::ordered_begin() const
> {
> return const_assoc_iterator(subs::assoc(this).begin());
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::assoc_iterator
> basic_ptree<K, D, C>::not_found()
> {
> return assoc_iterator(subs::assoc(this).end());
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::const_assoc_iterator
> basic_ptree<K, D, C>::not_found() const
> {
> return const_assoc_iterator(subs::assoc(this).end());
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::assoc_iterator
> basic_ptree<K, D, C>::find(const key_type &key)
> {
> return assoc_iterator(subs::assoc(this).find(key));
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::const_assoc_iterator
> basic_ptree<K, D, C>::find(const key_type &key) const
> {
> return const_assoc_iterator(subs::assoc(this).find(key));
> }
>
> template<class K, class D, class C> inline
> std::pair<
> typename basic_ptree<K, D, C>::assoc_iterator,
> typename basic_ptree<K, D, C>::assoc_iterator
> > basic_ptree<K, D, C>::equal_range(const key_type &key)
> {
> std::pair<typename subs::by_name_index::iterator,
> typename subs::by_name_index::iterator> r(
> subs::assoc(this).equal_range(key));
> return std::pair<assoc_iterator, assoc_iterator>(
> assoc_iterator(r.first), assoc_iterator(r.second));
> }
>
> template<class K, class D, class C> inline
> std::pair<
> typename basic_ptree<K, D, C>::const_assoc_iterator,
> typename basic_ptree<K, D, C>::const_assoc_iterator
> > basic_ptree<K, D, C>::equal_range(const key_type &key) const
> {
> std::pair<typename subs::by_name_index::const_iterator,
> typename subs::by_name_index::const_iterator> r(
> subs::assoc(this).equal_range(key));
> return std::pair<const_assoc_iterator, const_assoc_iterator>(
> const_assoc_iterator(r.first), const_assoc_iterator(r.second));
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::size_type
> basic_ptree<K, D, C>::count(const key_type &key) const
> {
> return subs::assoc(this).count(key);
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::size_type
> basic_ptree<K, D, C>::erase(const key_type &key)
> {
> return subs::assoc(this).erase(key);
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::iterator
> basic_ptree<K, D, C>::to_iterator(assoc_iterator ai)
> {
> return iterator(subs::ch(this).
> template project<0>(ai.base()));
> }
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::const_iterator
> basic_ptree<K, D, C>::to_iterator(const_assoc_iterator ai) const
> {
> return const_iterator(subs::ch(this).
> template project<0>(ai.base()));
> }
>
>
>
> template<class K, class D, class C> inline
> typename basic_ptree<K, D, C>::data_type &
> basic_ptree<K, D, C>::data()
> {
> return m_data;
> }
>
> template<class K, class D, class C> inline
> const typename basic_ptree<K, D, C>::data_type &
> basic_ptree<K, D, C>::data() const
> {
> return m_data;
> }
>
> template<class K, class D, class C> inline
> void basic_ptree<K, D, C>::clear()
> {
> m_data = data_type();
> subs::ch(this).clear();
> }
>
> template<class K, class D, class C>
> basic_ptree<K, D, C> &
> basic_ptree<K, D, C>::get_child(const path_type &path)
> {
> path_type p(path);
> self_type *n = walk_path(p);
> if (!n) {
> ::boost::exception_detail::throw_exception_(ptree_bad_path("No such node", path),__PRETTY_FUNCTION__,"/usr/include/boost/property_tree/detail/ptree_implementation.hpp",557);
> }
> return *n;
> }
>
> template<class K, class D, class C> inline
> const basic_ptree<K, D, C> &
> basic_ptree<K, D, C>::get_child(const path_type &path) const
> {
> return const_cast<self_type*>(this)->get_child(path);
> }
>
> template<class K, class D, class C> inline
> basic_ptree<K, D, C> &
> basic_ptree<K, D, C>::get_child(const path_type &path,
> self_type &default_value)
> {
> path_type p(path);
> self_type *n = walk_path(p);
> return n ? *n : default_value;
> }
>
> template<class K, class D, class C> inline
> const basic_ptree<K, D, C> &
> basic_ptree<K, D, C>::get_child(const path_type &path,
> const self_type &default_value) const
> {
> return const_cast<self_type*>(this)->get_child(path,
> const_cast<self_type&>(default_value));
> }
>
>
> template<class K, class D, class C>
> optional<basic_ptree<K, D, C> &>
> basic_ptree<K, D, C>::get_child_optional(const path_type &path)
> {
> path_type p(path);
> self_type *n = walk_path(p);
> if (!n) {
> return optional<self_type&>();
> }
> return *n;
> }
>
> template<class K, class D, class C>
> optional<const basic_ptree<K, D, C> &>
> basic_ptree<K, D, C>::get_child_optional(const path_type &path) const
> {
> path_type p(path);
> self_type *n = walk_path(p);
> if (!n) {
> return optional<const self_type&>();
> }
> return *n;
> }
>
> template<class K, class D, class C>
> basic_ptree<K, D, C> &
> basic_ptree<K, D, C>::put_child(const path_type &path,
> const self_type &value)
> {
> path_type p(path);
> self_type &parent = force_path(p);
>
> key_type fragment = p.reduce();
> assoc_iterator el = parent.find(fragment);
>
> if(el != parent.not_found()) {
> return el->second = value;
> } else {
> return parent.push_back(value_type(fragment, value))->second;
> }
> }
>
> template<class K, class D, class C>
> basic_ptree<K, D, C> &
> basic_ptree<K, D, C>::add_child(const path_type &path,
> const self_type &value)
> {
> path_type p(path);
> self_type &parent = force_path(p);
>
> key_type fragment = p.reduce();
> return parent.push_back(value_type(fragment, value))->second;
> }
>
> template<class K, class D, class C>
> template<class Type, class Translator>
> typename boost::enable_if<detail::is_translator<Translator>, Type>::type
> basic_ptree<K, D, C>::get_value(Translator tr) const
> {
> if(boost::optional<Type> o = get_value_optional<Type>(tr)) {
> return *o;
> }
> ::boost::exception_detail::throw_exception_(ptree_bad_data( std::string("conversion of data to type \"") + typeid(Type).name() + "\" failed", data()),__PRETTY_FUNCTION__,
>
> "/usr/include/boost/property_tree/detail/ptree_implementation.hpp"
># 651 "/usr/include/boost/property_tree/detail/ptree_implementation.hpp" 3
> ,
>
> 653
># 651 "/usr/include/boost/property_tree/detail/ptree_implementation.hpp" 3
> )
>
> ;
> }
>
> template<class K, class D, class C>
> template<class Type> inline
> Type basic_ptree<K, D, C>::get_value() const
> {
> return get_value<Type>(
> typename translator_between<data_type, Type>::type());
> }
>
> template<class K, class D, class C>
> template<class Type, class Translator> inline
> Type basic_ptree<K, D, C>::get_value(const Type &default_value,
> Translator tr) const
> {
> return get_value_optional<Type>(tr).get_value_or(default_value);
> }
>
> template<class K, class D, class C>
> template <class Ch, class Translator>
> typename boost::enable_if<
> detail::is_character<Ch>,
> std::basic_string<Ch>
> >::type
> basic_ptree<K, D, C>::get_value(const Ch *default_value, Translator tr)const
> {
> return get_value<std::basic_string<Ch>, Translator>(default_value, tr);
> }
>
> template<class K, class D, class C>
> template<class Type> inline
> typename boost::disable_if<detail::is_translator<Type>, Type>::type
> basic_ptree<K, D, C>::get_value(const Type &default_value) const
> {
> return get_value(default_value,
> typename translator_between<data_type, Type>::type());
> }
>
> template<class K, class D, class C>
> template <class Ch>
> typename boost::enable_if<
> detail::is_character<Ch>,
> std::basic_string<Ch>
> >::type
> basic_ptree<K, D, C>::get_value(const Ch *default_value) const
> {
> return get_value< std::basic_string<Ch> >(default_value);
> }
>
> template<class K, class D, class C>
> template<class Type, class Translator> inline
> optional<Type> basic_ptree<K, D, C>::get_value_optional(
> Translator tr) const
> {
> return tr.get_value(data());
> }
>
> template<class K, class D, class C>
> template<class Type> inline
> optional<Type> basic_ptree<K, D, C>::get_value_optional() const
> {
> return get_value_optional<Type>(
> typename translator_between<data_type, Type>::type());
> }
>
> template<class K, class D, class C>
> template<class Type, class Translator> inline
> typename boost::enable_if<detail::is_translator<Translator>, Type>::type
> basic_ptree<K, D, C>::get(const path_type &path,
> Translator tr) const
> {
> return get_child(path).template get_value<Type>(tr);
> }
>
> template<class K, class D, class C>
> template<class Type> inline
> Type basic_ptree<K, D, C>::get(const path_type &path) const
> {
> return get_child(path).template get_value<Type>();
> }
>
> template<class K, class D, class C>
> template<class Type, class Translator> inline
> Type basic_ptree<K, D, C>::get(const path_type &path,
> const Type &default_value,
> Translator tr) const
> {
> return get_optional<Type>(path, tr).get_value_or(default_value);
> }
>
> template<class K, class D, class C>
> template <class Ch, class Translator>
> typename boost::enable_if<
> detail::is_character<Ch>,
> std::basic_string<Ch>
> >::type
> basic_ptree<K, D, C>::get(
> const path_type &path, const Ch *default_value, Translator tr) const
> {
> return get<std::basic_string<Ch>, Translator>(path, default_value, tr);
> }
>
> template<class K, class D, class C>
> template<class Type> inline
> typename boost::disable_if<detail::is_translator<Type>, Type>::type
> basic_ptree<K, D, C>::get(const path_type &path,
> const Type &default_value) const
> {
> return get_optional<Type>(path).get_value_or(default_value);
> }
>
> template<class K, class D, class C>
> template <class Ch>
> typename boost::enable_if<
> detail::is_character<Ch>,
> std::basic_string<Ch>
> >::type
> basic_ptree<K, D, C>::get(
> const path_type &path, const Ch *default_value) const
> {
> return get< std::basic_string<Ch> >(path, default_value);
> }
>
> template<class K, class D, class C>
> template<class Type, class Translator>
> optional<Type> basic_ptree<K, D, C>::get_optional(const path_type &path,
> Translator tr) const
> {
> if (optional<const self_type&> child = get_child_optional(path))
> return child.get().
> template get_value_optional<Type>(tr);
> else
> return optional<Type>();
> }
>
> template<class K, class D, class C>
> template<class Type>
> optional<Type> basic_ptree<K, D, C>::get_optional(
> const path_type &path) const
> {
> if (optional<const self_type&> child = get_child_optional(path))
> return child.get().template get_value_optional<Type>();
> else
> return optional<Type>();
> }
>
> template<class K, class D, class C>
> template<class Type, class Translator>
> void basic_ptree<K, D, C>::put_value(const Type &value, Translator tr)
> {
> if(optional<data_type> o = tr.put_value(value)) {
> data() = *o;
> } else {
> ::boost::exception_detail::throw_exception_(ptree_bad_data( std::string("conversion of type \"") + typeid(Type).name() + "\" to data failed", boost::any()),__PRETTY_FUNCTION__,
>
> "/usr/include/boost/property_tree/detail/ptree_implementation.hpp"
># 807 "/usr/include/boost/property_tree/detail/ptree_implementation.hpp" 3
> ,
>
> 809
># 807 "/usr/include/boost/property_tree/detail/ptree_implementation.hpp" 3
> )
>
> ;
> }
> }
>
> template<class K, class D, class C>
> template<class Type> inline
> void basic_ptree<K, D, C>::put_value(const Type &value)
> {
> put_value(value, typename translator_between<data_type, Type>::type());
> }
>
> template<class K, class D, class C>
> template<class Type, typename Translator>
> basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
> const path_type &path, const Type &value, Translator tr)
> {
> if(optional<self_type &> child = get_child_optional(path)) {
> child.get().put_value(value, tr);
> return *child;
> } else {
> self_type &child2 = put_child(path, self_type());
> child2.put_value(value, tr);
> return child2;
> }
> }
>
> template<class K, class D, class C>
> template<class Type> inline
> basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
> const path_type &path, const Type &value)
> {
> return put(path, value,
> typename translator_between<data_type, Type>::type());
> }
>
> template<class K, class D, class C>
> template<class Type, typename Translator> inline
> basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
> const path_type &path, const Type &value, Translator tr)
> {
> self_type &child = add_child(path, self_type());
> child.put_value(value, tr);
> return child;
> }
>
> template<class K, class D, class C>
> template<class Type> inline
> basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
> const path_type &path, const Type &value)
> {
> return add(path, value,
> typename translator_between<data_type, Type>::type());
> }
>
>
> template<class K, class D, class C>
> basic_ptree<K, D, C> *
> basic_ptree<K, D, C>::walk_path(path_type &p) const
> {
> if(p.empty()) {
>
> return const_cast<basic_ptree*>(this);
> }
>
> key_type fragment = p.reduce();
> const_assoc_iterator el = find(fragment);
> if(el == not_found()) {
>
> return 0;
> }
>
> return el->second.walk_path(p);
> }
>
> template<class K, class D, class C>
> basic_ptree<K, D, C> & basic_ptree<K, D, C>::force_path(path_type &p)
> {
> ((void)0);
> if(p.single()) {
>
> return *this;
> }
> key_type fragment = p.reduce();
> assoc_iterator el = find(fragment);
>
>
> self_type& child = el == not_found() ?
> push_back(value_type(fragment, self_type()))->second : el->second;
> return child.force_path(p);
> }
>
>
>
> template<class K, class D, class C>
> inline void swap(basic_ptree<K, D, C> &pt1, basic_ptree<K, D, C> &pt2)
> {
> pt1.swap(pt2);
> }
>
>} }
># 517 "/usr/include/boost/property_tree/ptree.hpp" 2 3 4
># 25 "../src/target.h" 2
>
>
>
>const uint32_t matchMaxTimeDiff = 1000;
>
>
>
>namespace iwf
>{
> extern const char* targetFileNameBase;
> extern const char* targetFileNameExt;
> extern const char* imageExtension;
> extern const char* dataExtension;
>}
>
>const uint32_t maxInactiveScans = 1;
>
>
>
>class targetData
>{
>public:
> targetData();
> ~targetData();
>
> position centre;
> position centroid;
> double width;
> double height;
> double peakDensity;
> double meanDensity;
> double edgeSharpnessLeft;
> double edgeSharpnessRight;
> double maxDistance;
> double minDistance;
> double meanDistance;
> bool multipleDistances;
> position startPos;
> position endPos;
> position peakPos;
> time_t captureTime;
> std::list<pointData> points;
>
> bool writeSelfToFile(std::ostream &out);
> bool readSelfFromFile(std::istream &in);
> bool findPoint(position pos, pointData &pd);
>};
>
>class hlistData
>{
> bool isCurrent;
>};
>
>
>
>
>typedef std::list<targetData *> targetDataList;
>
>
>
>
>
>
>
>class targetFullDataList:std::list<targetDataList>
>{
> std::list<hlistData> hlists;
>};
>
>typedef uint32_t targetID_t;
>
>
>
>
>
>
>class target
>{
>public:
>
>
>
> target(uint32_t id, targetData *data);
> target(void);
> ~target(void);
> void ignore(uint32_t time, double growth, double densityChange);
> void acknowledge(void);
> void annul(std::string &message);
> bool updateData(targetData* td);
> bool update(time_t t);
> void forget(void);
> void restore(void);
> bool readSelfFromFile(void);
> bool writeSelfToFile(void);
> void updateParameters(void);
> std::list<std::string> *getFiles(position pos, time_t time);
> bool deleteDataFiles(void);
> dataFileList *getAllDataFiles(void);
> void purge(void);
> bool touch(void){return writeSelfToFile();};
>
> targetID_t ID;
> targetData *currentData;
> std::string fileName;
> std::string annulMessage;
> double growth;
> double velocity1;
> double velocity2;
> double thickening1;
> double thickening2;
>
> bool active;
> bool annulled;
> bool acknowledged;
> bool forgotten;
> bool ignored;
> bool verified;
> bool ignoreActive;
> time_t ignoreDelay;
> double ignoreGrowth;
> double ignoreDensity;
> double lastIgnoreWidth;
> double lastIgnoreDensity;
> time_t lastAckTime;
> time_t lastIgnoreTime;
> time_t lastUpdateTime;
>
>
>
>
>
>
> targetFullDataList allData;
> targetDataList currentDataList;
>
>
>
> bool updated;
> bool purged;
> bool written;
> uint32_t inactiveScans;
>};
>
>
>
>bool scanForTargets(positioner *position, std::list<targetData *> &result);
>targetData *createTargetData(positioner *position, std::list<uint32_t> &regionPoints);
>
>
>
>double compareTargets(target *theTarget, targetData *data2);
>
>
>
>
>inline double centroidConvert(double ratio){return ratio;};
>
>
>
>
>inline double meanConvert(double ratio){return ratio;};
>
>
>std::ostream &operator << (std::ostream &out, target &t);
>std::istream &operator >> (std::istream &in, target &t);
># 19 "../src/io.h" 2
># 1 "/usr/include/boost/thread.hpp" 1 3 4
># 13 "/usr/include/boost/thread.hpp" 3 4
># 1 "/usr/include/boost/thread/thread.hpp" 1 3 4
># 12 "/usr/include/boost/thread/thread.hpp" 3 4
># 1 "/usr/include/boost/thread/thread_only.hpp" 1 3 4
># 12 "/usr/include/boost/thread/thread_only.hpp" 3 4
># 1 "/usr/include/boost/thread/detail/platform.hpp" 1 3 4
># 17 "/usr/include/boost/thread/detail/platform.hpp" 3 4
># 1 "/usr/include/boost/config/requires_threads.hpp" 1 3 4
># 18 "/usr/include/boost/thread/detail/platform.hpp" 2 3 4
># 13 "/usr/include/boost/thread/thread_only.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/thread/pthread/thread_data.hpp" 1 3 4
># 9 "/usr/include/boost/thread/pthread/thread_data.hpp" 3 4
># 1 "/usr/include/boost/thread/detail/config.hpp" 1 3 4
># 428 "/usr/include/boost/thread/detail/config.hpp" 3 4
># 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
># 429 "/usr/include/boost/thread/detail/config.hpp" 2 3 4
># 10 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
># 1 "/usr/include/boost/thread/exceptions.hpp" 1 3 4
># 26 "/usr/include/boost/thread/exceptions.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 27 "/usr/include/boost/thread/exceptions.hpp" 2 3 4
>
>namespace boost
>{
>
>
> class __attribute__((__visibility__("default"))) thread_interrupted
> {};
>
>
> class __attribute__((__visibility__("default"))) thread_exception:
> public system::system_error
>
> {
> typedef system::system_error base_type;
> public:
> thread_exception()
> : base_type(0,system::system_category())
> {}
>
> thread_exception(int sys_error_code)
> : base_type(sys_error_code, system::system_category())
> {}
>
> thread_exception( int ev, const char * what_arg )
> : base_type(system::error_code(ev, system::system_category()), what_arg)
> {
> }
> thread_exception( int ev, const std::string & what_arg )
> : base_type(system::error_code(ev, system::system_category()), what_arg)
> {
> }
>
> ~thread_exception() throw()
> {}
>
>
> int native_error() const
> {
> return code().value();
> }
>
> };
>
> class __attribute__((__visibility__("default"))) condition_error:
> public system::system_error
>
> {
> typedef system::system_error base_type;
> public:
> condition_error()
> : base_type(system::error_code(0, system::system_category()), "Condition error")
> {}
> condition_error( int ev )
> : base_type(system::error_code(ev, system::system_category()), "Condition error")
> {
> }
> condition_error( int ev, const char * what_arg )
> : base_type(system::error_code(ev, system::system_category()), what_arg)
> {
> }
> condition_error( int ev, const std::string & what_arg )
> : base_type(system::error_code(ev, system::system_category()), what_arg)
> {
> }
> };
>
>
> class __attribute__((__visibility__("default"))) lock_error:
> public thread_exception
> {
> typedef thread_exception base_type;
> public:
> lock_error()
> : base_type(0, "boost::lock_error")
> {}
>
> lock_error( int ev )
> : base_type(ev, "boost::lock_error")
> {
> }
> lock_error( int ev, const char * what_arg )
> : base_type(ev, what_arg)
> {
> }
> lock_error( int ev, const std::string & what_arg )
> : base_type(ev, what_arg)
> {
> }
>
> ~lock_error() throw()
> {}
>
> };
>
> class __attribute__((__visibility__("default"))) thread_resource_error:
> public thread_exception
> {
> typedef thread_exception base_type;
> public:
> thread_resource_error()
> : base_type(system::errc::resource_unavailable_try_again, "boost::thread_resource_error")
> {}
>
> thread_resource_error( int ev )
> : base_type(ev, "boost::thread_resource_error")
> {
> }
> thread_resource_error( int ev, const char * what_arg )
> : base_type(ev, what_arg)
> {
> }
> thread_resource_error( int ev, const std::string & what_arg )
> : base_type(ev, what_arg)
> {
> }
>
>
> ~thread_resource_error() throw()
> {}
>
> };
>
> class __attribute__((__visibility__("default"))) unsupported_thread_option:
> public thread_exception
> {
> typedef thread_exception base_type;
> public:
> unsupported_thread_option()
> : base_type(system::errc::invalid_argument, "boost::unsupported_thread_option")
> {}
>
> unsupported_thread_option( int ev )
> : base_type(ev, "boost::unsupported_thread_option")
> {
> }
> unsupported_thread_option( int ev, const char * what_arg )
> : base_type(ev, what_arg)
> {
> }
> unsupported_thread_option( int ev, const std::string & what_arg )
> : base_type(ev, what_arg)
> {
> }
>
> };
>
> class __attribute__((__visibility__("default"))) invalid_thread_argument:
> public thread_exception
> {
> typedef thread_exception base_type;
> public:
> invalid_thread_argument()
> : base_type(system::errc::invalid_argument, "boost::invalid_thread_argument")
> {}
>
> invalid_thread_argument( int ev )
> : base_type(ev, "boost::invalid_thread_argument")
> {
> }
> invalid_thread_argument( int ev, const char * what_arg )
> : base_type(ev, what_arg)
> {
> }
> invalid_thread_argument( int ev, const std::string & what_arg )
> : base_type(ev, what_arg)
> {
> }
>
> };
>
> class __attribute__((__visibility__("default"))) thread_permission_error:
> public thread_exception
> {
> typedef thread_exception base_type;
> public:
> thread_permission_error()
> : base_type(system::errc::permission_denied, "boost::thread_permission_error")
> {}
>
> thread_permission_error( int ev )
> : base_type(ev, "boost::thread_permission_error")
> {
> }
> thread_permission_error( int ev, const char * what_arg )
> : base_type(ev, what_arg)
> {
> }
> thread_permission_error( int ev, const std::string & what_arg )
> : base_type(ev, what_arg)
> {
> }
>
> };
>
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 224 "/usr/include/boost/thread/exceptions.hpp" 2 3 4
># 11 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
># 1 "/usr/include/boost/thread/lock_guard.hpp" 1 3 4
># 11 "/usr/include/boost/thread/lock_guard.hpp" 3 4
># 1 "/usr/include/boost/thread/detail/delete.hpp" 1 3 4
># 12 "/usr/include/boost/thread/lock_guard.hpp" 2 3 4
># 1 "/usr/include/boost/thread/detail/move.hpp" 1 3 4
># 20 "/usr/include/boost/thread/detail/move.hpp" 3 4
># 1 "/usr/include/boost/move/utility.hpp" 1 3 4
># 17 "/usr/include/boost/move/utility.hpp" 3 4
># 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
># 18 "/usr/include/boost/move/utility.hpp" 2 3 4
># 1 "/usr/include/boost/move/core.hpp" 1 3 4
># 19 "/usr/include/boost/move/core.hpp" 3 4
># 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
># 20 "/usr/include/boost/move/core.hpp" 2 3 4
># 242 "/usr/include/boost/move/core.hpp" 3 4
> namespace boost {
>
>
>
>
> template<class T>
> struct has_move_emulation_enabled
> {
> static const bool value = false;
> };
>
> }
># 330 "/usr/include/boost/move/core.hpp" 3 4
># 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
># 331 "/usr/include/boost/move/core.hpp" 2 3 4
># 19 "/usr/include/boost/move/utility.hpp" 2 3 4
># 1 "/usr/include/boost/move/detail/meta_utils.hpp" 1 3 4
># 17 "/usr/include/boost/move/detail/meta_utils.hpp" 3 4
># 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
># 18 "/usr/include/boost/move/detail/meta_utils.hpp" 2 3 4
>
>
>
>namespace boost {
>namespace move_detail {
>
>
>template<bool C, typename T1, typename T2>
>struct if_c
>{
> typedef T1 type;
>};
>
>template<typename T1, typename T2>
>struct if_c<false,T1,T2>
>{
> typedef T2 type;
>};
>
>template<typename T1, typename T2, typename T3>
>struct if_
>{
> typedef typename if_c<0 != T1::value, T2, T3>::type type;
>};
>
>
>template <bool B, class T = void>
>struct enable_if_c
>{
> typedef T type;
>};
>
>template <class T>
>struct enable_if_c<false, T> {};
>
>template <class Cond, class T = void>
>struct enable_if : public enable_if_c<Cond::value, T> {};
>
>template <class Cond, class T = void>
>struct disable_if : public enable_if_c<!Cond::value, T> {};
>
>
>template<class T, T v>
>struct integral_constant
>{
> static const T value = v;
> typedef T value_type;
> typedef integral_constant<T, v> type;
>};
>
>
>template <class T>
>struct identity
>{
> typedef T type;
>};
>
>
>template <class T, class U>
>class is_convertible
>{
> typedef char true_t;
> class false_t { char dummy[2]; };
> static true_t dispatch(U);
> static false_t dispatch(...);
> static T &trigger();
> public:
> enum { value = sizeof(dispatch(trigger())) == sizeof(true_t) };
>};
>
>
>template <typename Condition1, typename Condition2, typename Condition3 = integral_constant<bool, true> >
>struct and_
> : public integral_constant<bool, Condition1::value && Condition2::value && Condition3::value>
>{};
>
>template <typename Boolean>
>struct not_
> : public integral_constant<bool, !Boolean::value>
>{};
>
>
>template<class T>
>struct is_lvalue_reference
> : public integral_constant<bool, false>
>{};
>
>template<class T>
>struct is_lvalue_reference<T&>
> : public integral_constant<bool, true>
>{};
>
>template<class T>
>struct is_class_or_union
>{
> struct twochar { char _[2]; };
> template <class U>
> static char is_class_or_union_tester(void(U::*)(void));
> template <class U>
> static twochar is_class_or_union_tester(...);
> static const bool value = sizeof(is_class_or_union_tester<T>(0)) == sizeof(char);
>};
>
>struct empty{};
>
>
>template<class T> struct addr_impl_ref
>{
> T & v_;
> inline addr_impl_ref( T & v ): v_( v ) {}
> inline operator T& () const { return v_; }
>
> private:
> addr_impl_ref & operator=(const addr_impl_ref &);
>};
>
>template<class T> struct addressof_impl
>{
> static inline T * f( T & v, long )
> {
> return reinterpret_cast<T*>(
> &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
> }
>
> static inline T * f( T * v, int )
> { return v; }
>};
>
>template<class T>
>inline T * addressof( T & v )
>{
> return ::boost::move_detail::addressof_impl<T>::f
> ( ::boost::move_detail::addr_impl_ref<T>( v ), 0 );
>}
>
>}
>}
>
># 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
># 157 "/usr/include/boost/move/detail/meta_utils.hpp" 2 3 4
># 20 "/usr/include/boost/move/utility.hpp" 2 3 4
># 101 "/usr/include/boost/move/utility.hpp" 3 4
> namespace boost {
>
>
>
>
>
>
>
> template<class T>
> struct enable_move_utility_emulation
> {
> static const bool value = false;
> };
># 137 "/usr/include/boost/move/utility.hpp" 3 4
> template <class T>
> inline typename remove_reference<T>::type && move(T&& t)
> { return static_cast<typename remove_reference<T>::type &&>(t); }
># 175 "/usr/include/boost/move/utility.hpp" 3 4
> template <class T, class U>
> inline T&& forward(U&& t
> , typename ::boost::move_detail::enable_if_c<
> move_detail::is_lvalue_reference<T>::value ? move_detail::is_lvalue_reference::value : true>::type * = 0
>
>
> )
> { return static_cast<T&&>(t); }
>
>
>
> }
>
>
>
>
>
># 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
># 193 "/usr/include/boost/move/utility.hpp" 2 3 4
># 21 "/usr/include/boost/thread/detail/move.hpp" 2 3 4
># 1 "/usr/include/boost/move/traits.hpp" 1 3 4
># 17 "/usr/include/boost/move/traits.hpp" 3 4
># 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
># 18 "/usr/include/boost/move/traits.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost {
># 36 "/usr/include/boost/move/traits.hpp" 3 4
>template <class T>
>struct has_trivial_destructor_after_move
> : ::boost::has_trivial_destructor<T>
>{};
>
>
>
>template <class T>
>struct has_nothrow_move
> : public ::boost::move_detail::integral_constant<bool, false>
>{};
>
>namespace move_detail {
>
>
>
>
> template< class T> struct forward_type { typedef T type; };
># 64 "/usr/include/boost/move/traits.hpp" 3 4
>template< class T > struct is_rvalue_reference : ::boost::move_detail::integral_constant<bool, false> { };
>
> template< class T > struct is_rvalue_reference< T&& > : ::boost::move_detail::integral_constant<bool, true> { };
># 78 "/usr/include/boost/move/traits.hpp" 3 4
> template< class T > struct add_rvalue_reference { typedef T&& type; };
># 105 "/usr/include/boost/move/traits.hpp" 3 4
>template< class T > struct remove_rvalue_reference { typedef T type; };
>
>
> template< class T > struct remove_rvalue_reference< T&& > { typedef T type; };
># 120 "/usr/include/boost/move/traits.hpp" 3 4
>template <typename T>
>typename boost::move_detail::add_rvalue_reference<T>::type declval();
>
>}
># 138 "/usr/include/boost/move/traits.hpp" 3 4
>}
>
># 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
># 141 "/usr/include/boost/move/traits.hpp" 2 3 4
># 22 "/usr/include/boost/thread/detail/move.hpp" 2 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 23 "/usr/include/boost/thread/detail/move.hpp" 2 3 4
>
>namespace boost
>{
>
> namespace detail
> {
> template <typename T>
> struct enable_move_utility_emulation_dummy_specialization;
> template<typename T>
> struct thread_move_t
> {
> T& t;
> explicit thread_move_t(T& t_):
> t(t_)
> {}
>
> T& operator*() const
> {
> return t;
> }
>
> T* operator->() const
> {
> return &t;
> }
> private:
> void operator=(thread_move_t&);
> };
> }
>
>
>
>
> template<typename T>
> typename enable_if<boost::is_convertible<T&,boost::detail::thread_move_t<T> >, boost::detail::thread_move_t<T> >::type move(T& t)
> {
> return boost::detail::thread_move_t<T>(t);
> }
>
>
> template<typename T>
> boost::detail::thread_move_t<T> move(boost::detail::thread_move_t<T> t)
> {
> return t;
> }
>
>
>}
># 239 "/usr/include/boost/thread/detail/move.hpp" 3 4
>namespace boost
>{ namespace thread_detail
> {
>
> template <class T>
> typename decay<T>::type
> decay_copy(T&& t)
> {
> return boost::forward<T>(t);
> }
># 257 "/usr/include/boost/thread/detail/move.hpp" 3 4
> }
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 261 "/usr/include/boost/thread/detail/move.hpp" 2 3 4
># 13 "/usr/include/boost/thread/lock_guard.hpp" 2 3 4
># 1 "/usr/include/boost/thread/detail/lockable_wrapper.hpp" 1 3 4
># 14 "/usr/include/boost/thread/detail/lockable_wrapper.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 15 "/usr/include/boost/thread/detail/lockable_wrapper.hpp" 2 3 4
>
>namespace boost
>{
>
>
> namespace thread_detail
> {
> template <typename Mutex>
> struct lockable_wrapper
> {
> Mutex* m;
> explicit lockable_wrapper(Mutex& m_) :
> m(&m_)
> {}
> };
> template <typename Mutex>
> struct lockable_adopt_wrapper
> {
> Mutex* m;
> explicit lockable_adopt_wrapper(Mutex& m_) :
> m(&m_)
> {}
> };
> }
>
>
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 44 "/usr/include/boost/thread/detail/lockable_wrapper.hpp" 2 3 4
># 14 "/usr/include/boost/thread/lock_guard.hpp" 2 3 4
># 1 "/usr/include/boost/thread/lock_options.hpp" 1 3 4
># 10 "/usr/include/boost/thread/lock_options.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 11 "/usr/include/boost/thread/lock_options.hpp" 2 3 4
>
>namespace boost
>{
> struct defer_lock_t
> {
> };
> struct try_to_lock_t
> {
> };
> struct adopt_lock_t
> {
> };
>
> constexpr defer_lock_t defer_lock = {};
> constexpr try_to_lock_t try_to_lock = {};
> constexpr adopt_lock_t adopt_lock = {};
>
>}
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 30 "/usr/include/boost/thread/lock_options.hpp" 2 3 4
># 15 "/usr/include/boost/thread/lock_guard.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 21 "/usr/include/boost/thread/lock_guard.hpp" 2 3 4
>
>namespace boost
>{
>
> template <typename Mutex>
> class lock_guard
> {
> private:
> Mutex& m;
>
> public:
> typedef Mutex mutex_type;
> lock_guard(lock_guard const&) = delete; lock_guard& operator=(lock_guard const&) = delete;
>
> explicit lock_guard(Mutex& m_) :
> m(m_)
> {
> m.lock();
> }
>
> lock_guard(Mutex& m_, adopt_lock_t) :
> m(m_)
> {
>
>
>
> }
>
>
> lock_guard(std::initializer_list<thread_detail::lockable_wrapper<Mutex> > l_) :
> m(*(const_cast<thread_detail::lockable_wrapper<Mutex>*>(l_.begin())->m))
> {
> m.lock();
> }
>
> lock_guard(std::initializer_list<thread_detail::lockable_adopt_wrapper<Mutex> > l_) :
> m(*(const_cast<thread_detail::lockable_adopt_wrapper<Mutex>*>(l_.begin())->m))
> {
>
>
>
> }
>
>
> ~lock_guard()
> {
> m.unlock();
> }
> };
>
>
>
> template <typename Lockable>
> lock_guard<Lockable> make_lock_guard(Lockable& mtx)
> {
> return { thread_detail::lockable_wrapper<Lockable>(mtx) };
> }
> template <typename Lockable>
> lock_guard<Lockable> make_lock_guard(Lockable& mtx, adopt_lock_t)
> {
> return { thread_detail::lockable_adopt_wrapper<Lockable>(mtx) };
> }
>
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 87 "/usr/include/boost/thread/lock_guard.hpp" 2 3 4
># 12 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
># 1 "/usr/include/boost/thread/lock_types.hpp" 1 3 4
># 14 "/usr/include/boost/thread/lock_types.hpp" 3 4
># 1 "/usr/include/boost/thread/lockable_traits.hpp" 1 3 4
># 12 "/usr/include/boost/thread/lockable_traits.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 13 "/usr/include/boost/thread/lockable_traits.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 17 "/usr/include/boost/thread/lockable_traits.hpp" 2 3 4
>
>
>
>namespace boost
>{
> namespace sync
> {
># 34 "/usr/include/boost/thread/lockable_traits.hpp" 3 4
> namespace detail
> {
># 70 "/usr/include/boost/thread/lockable_traits.hpp" 3 4
> template<typename T, bool=boost::is_class<T>::value> struct has_member_called_lock { static const bool value=false; }; template<typename T> struct has_member_called_lock<T,true> { typedef char true_type; struct false_type { true_type dummy[2]; }; struct fallback { int lock; }; struct derived: T, fallback { derived(); }; template<int fallback::*> struct tester; template<typename U> static false_type has_member(tester<&U::lock>*); template<typename U> static true_type has_member(...); static const bool value=sizeof(has_member<derived>(0))==sizeof(true_type); }
>; template<typename T, bool=boost::is_class<T>::value> struct has_member_called_unlock { static const bool value=false; }; template<typename T> struct has_member_called_unlock<T,true> { typedef char true_type; struct false_type { true_type dummy[2]; }; struct fallback { int unlock; }; struct derived: T, fallback { derived(); }; template<int fallback::*> struct tester; template<typename U> static false_type has_member(tester<&U::unlock>*); template<typename U> static true_type has_member(...); static const bool value=sizeof(has_member<derived>(0))==sizeof(true_type); };
> template<typename T, bool=boost::is_class<T>::value> struct has_member_called_try_lock { static const bool value=false; }; template<typename T> struct has_member_called_try_lock<T,true> { typedef char true_type; struct false_type { true_type dummy[2]; }; struct fallback { int try_lock; }; struct derived: T, fallback { derived(); }; template<int fallback::*> struct tester; template<typename U> static false_type has_member(tester<&U::try_lock>*); template<typename U> static true_type has_member(...); static const bool value=sizeof(has_member<derived>(0))==sizeof(true_type); };
>
> template<typename T,bool=has_member_called_lock<T>::value >
> struct has_member_lock
> {
> static const bool value=false;
> };
>
> template<typename T>
> struct has_member_lock<T,true>
> {
> typedef char true_type;
> struct false_type
> {
> true_type dummy[2];
> };
>
> template<typename U,typename V>
> static true_type has_member(V (U::*)());
> template<typename U>
> static false_type has_member(U);
>
> static const bool value=sizeof(has_member_lock<T>::has_member(&T::lock))==sizeof(true_type)
> ;
> };
>
> template<typename T,bool=has_member_called_unlock<T>::value >
> struct has_member_unlock
> {
> static const bool value=false;
> };
>
> template<typename T>
> struct has_member_unlock<T,true>
> {
> typedef char true_type;
> struct false_type
> {
> true_type dummy[2];
> };
>
> template<typename U,typename V>
> static true_type has_member(V (U::*)());
> template<typename U>
> static false_type has_member(U);
>
> static const bool value=sizeof(has_member_unlock<T>::has_member(&T::unlock))==sizeof(true_type)
> ;
> };
>
> template<typename T,bool=has_member_called_try_lock<T>::value >
> struct has_member_try_lock
> {
> static const bool value=false;
> };
>
> template<typename T>
> struct has_member_try_lock<T,true>
> {
> typedef char true_type;
> struct false_type
> {
> true_type dummy[2];
> };
>
> template<typename U>
> static true_type has_member(bool (U::*)());
> template<typename U>
> static false_type has_member(U);
>
> static const bool value=sizeof(has_member_try_lock<T>::has_member(&T::try_lock))==sizeof(true_type)
> ;
> };
>
> }
>
> template<typename T>
> struct is_basic_lockable
> {
> static const bool value = detail::has_member_lock<T>::value && detail::has_member_unlock<T>::value
> ;
> };
> template<typename T>
> struct is_lockable
> {
> static const bool value = is_basic_lockable<T>::value && detail::has_member_try_lock<T>::value
>
> ;
> };
># 175 "/usr/include/boost/thread/lockable_traits.hpp" 3 4
> template<typename T>
> struct is_recursive_mutex_sur_parole
> {
> static const bool value = false;
> };
> template<typename T>
> struct is_recursive_mutex_sur_parolle : is_recursive_mutex_sur_parole<T>
> {
> };
>
> template<typename T>
> struct is_recursive_basic_lockable
> {
> static const bool value = is_basic_lockable<T>::value && is_recursive_mutex_sur_parolle<T>::value
> ;
> };
> template<typename T>
> struct is_recursive_lockable
> {
> static const bool value = is_lockable<T>::value && is_recursive_mutex_sur_parolle<T>::value
> ;
> };
> }
> template<typename T>
> struct is_mutex_type
> {
> static const bool value = sync::is_lockable<T>::value;
> };
>
>}
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 206 "/usr/include/boost/thread/lockable_traits.hpp" 2 3 4
># 15 "/usr/include/boost/thread/lock_types.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/thread/thread_time.hpp" 1 3 4
># 13 "/usr/include/boost/thread/thread_time.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 14 "/usr/include/boost/thread/thread_time.hpp" 2 3 4
>
>namespace boost
>{
> typedef boost::posix_time::ptime system_time;
>
> inline system_time get_system_time()
> {
>
> return boost::date_time::microsec_clock<system_time>::universal_time();
>
>
>
> }
>
> namespace detail
> {
> inline system_time get_system_time_sentinel()
> {
> return system_time(boost::posix_time::pos_infin);
> }
>
> inline unsigned long get_milliseconds_until(system_time const& target_time)
> {
> if(target_time.is_pos_infinity())
> {
> return ~(unsigned long)0;
> }
> system_time const now=get_system_time();
> if(target_time<=now)
> {
> return 0;
> }
> return static_cast<unsigned long>((target_time-now).total_milliseconds()+1);
> }
>
> }
>
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 54 "/usr/include/boost/thread/thread_time.hpp" 2 3 4
># 19 "/usr/include/boost/thread/lock_types.hpp" 2 3 4
>
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 21 "/usr/include/boost/thread/lock_types.hpp" 2 3 4
>
># 1 "/usr/include/boost/chrono/time_point.hpp" 1 3 4
># 33 "/usr/include/boost/chrono/time_point.hpp" 3 4
># 1 "/usr/include/boost/chrono/duration.hpp" 1 3 4
># 33 "/usr/include/boost/chrono/duration.hpp" 3 4
># 1 "/usr/include/boost/chrono/config.hpp" 1 3 4
># 216 "/usr/include/boost/chrono/config.hpp" 3 4
># 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
># 217 "/usr/include/boost/chrono/config.hpp" 2 3 4
># 34 "/usr/include/boost/chrono/duration.hpp" 2 3 4
># 1 "/usr/include/boost/chrono/detail/static_assert.hpp" 1 3 4
># 35 "/usr/include/boost/chrono/duration.hpp" 2 3 4
>
># 1 "/usr/include/c++/4.8.2/climits" 1 3 4
># 39 "/usr/include/c++/4.8.2/climits" 3 4
> 
># 40 "/usr/include/c++/4.8.2/climits" 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/climits" 2 3
># 37 "/usr/include/boost/chrono/duration.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/ratio/ratio.hpp" 1 3 4
># 35 "/usr/include/boost/ratio/ratio.hpp" 3 4
># 1 "/usr/include/boost/ratio/config.hpp" 1 3 4
># 13 "/usr/include/boost/ratio/config.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 14 "/usr/include/boost/ratio/config.hpp" 2 3 4
># 36 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
># 1 "/usr/include/boost/ratio/detail/mpl/abs.hpp" 1 3 4
># 32 "/usr/include/boost/ratio/detail/mpl/abs.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct abs_impl;
>
>template< typename T > struct abs_tag
>{
> typedef typename T::tag type;
>};
>
>template<
> typename N = na
> >
>struct abs
> : abs_impl<
> typename abs_tag<N>::type
> >::template apply<N>::type
>{
> 
>};
>
>template<> struct abs< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : abs< T1 > { }; }; template< typename Tag > struct lambda< abs< na > , Tag , int_<-1> > { typedef false_ is_le; typedef abs< na > result_; typedef abs< na > type; }; namespace aux { template< typename T1 > struct template_arity< abs< T1 > > : int_<1> { }; template<> struct template_arity< abs< na > > : int_<-1> { }; }
>
>template<
> typename T
> , T n1
> >
>struct abs_c
> : abs<integral_c<T,n1> >
>{
>};
># 73 "/usr/include/boost/ratio/detail/mpl/abs.hpp" 3 4
>template<>
>struct abs_impl<integral_c_tag>
>{
>
>
>
>
> template< typename N > struct apply
> : integral_c< typename N::value_type, ((N::value < 0) ? (-N::value) : N::value ) >
>
> {
> };
>};
>
>}}
># 37 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
># 1 "/usr/include/boost/ratio/detail/mpl/sign.hpp" 1 3 4
># 32 "/usr/include/boost/ratio/detail/mpl/sign.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag > struct sign_impl;
>
>template< typename T > struct sign_tag
>{
> typedef typename T::tag type;
>};
>
>template<
> typename N = na
> >
>struct sign
> : sign_impl<
> typename sign_tag<N>::type
> >::template apply<N>::type
>{
> 
>};
>
>template<> struct sign< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : sign< T1 > { }; }; template< typename Tag > struct lambda< sign< na > , Tag , int_<-1> > { typedef false_ is_le; typedef sign< na > result_; typedef sign< na > type; }; namespace aux { template< typename T1 > struct template_arity< sign< T1 > > : int_<1> { }; template<> struct template_arity< sign< na > > : int_<-1> { }; }
>
>template<
> typename T
> , T n1
> >
>struct sign_c
> : sign<integral_c<T,n1> >
>{
>};
># 73 "/usr/include/boost/ratio/detail/mpl/sign.hpp" 3 4
>template<>
>struct sign_impl<integral_c_tag>
>{
>
>
>
>
> template< typename N > struct apply
> : integral_c< typename N::value_type, (N::value == 0 ? 0 : (N::value < 0 ? -1 : 1)) >
>
> {
> };
>};
>
>}}
># 38 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
># 1 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 1 3 4
># 23 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/dependent_nttp.hpp" 1 3 4
># 24 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 2 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 25 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 2 3 4
># 36 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag1, typename Tag2 > struct gcd_impl;
>
>template< typename T > struct gcd_tag
>{
> typedef typename T::tag type;
>};
>
>template<
> typename N1 = na
> , typename N2 = na
> >
>struct gcd
> : gcd_impl<
> typename gcd_tag<N1>::type
> , typename gcd_tag<N2>::type
> >::template apply<N1, N2>::type
>{
> 
>};
>
>template<> struct gcd< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : gcd< T1 , T2 > { }; }; template< typename Tag > struct lambda< gcd< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef gcd< na , na > result_; typedef gcd< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< gcd< T1 , T2 > > : int_<2> { }; template<> struct template_arity< gcd< na , na > > : int_<-1> { }; }
>
>template<
> typename T
> , T n1
> , T n2
> >
>struct gcd_c
> : gcd<integral_c<T,n1>,integral_c<T,n2> >
>{
>};
>
>namespace aux {
>
>
>
>
>
>
> template< typename T1, boost::intmax_t n1, bool n1_is_0
> , typename T2, boost::intmax_t n2, bool n2_is_0 >
> struct gcd_aux
> : gcd_aux<T2, n2, n2==0, T1, (n1 % n2), (n1 % n2)==0>
> {};
>
> template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2>
> struct gcd_aux<T1, n1, false, T2, n2, true> : integral_c<T1, n1>
> {};
>
> template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2, bool C>
> struct gcd_aux<T1, n1, true, T2, n2, C> : integral_c<T2, n2>
> {};
># 110 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 3 4
>}
>
>template<>
>struct gcd_impl<integral_c_tag, integral_c_tag>
>{
> template< typename N1, typename N2 > struct apply
> : abs<aux::gcd_aux< typename N1::value_type, N1::value, N1::value==0,
> typename N2::value_type, N2::value, N2::value==0 > >
> {
> };
>};
>
>}}
># 39 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
># 1 "/usr/include/boost/ratio/detail/mpl/lcm.hpp" 1 3 4
># 24 "/usr/include/boost/ratio/detail/mpl/lcm.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 25 "/usr/include/boost/ratio/detail/mpl/lcm.hpp" 2 3 4
># 36 "/usr/include/boost/ratio/detail/mpl/lcm.hpp" 3 4
>namespace boost { namespace mpl {
>
>template< typename Tag1, typename Tag2 > struct lcm_impl;
>
>template< typename T > struct lcm_tag
>{
> typedef typename T::tag type;
>};
>
>template<
> typename N1 = na
> , typename N2 = na
> >
>struct lcm
> : lcm_impl<
> typename lcm_tag<N1>::type
> , typename lcm_tag<N2>::type
> >::template apply<N1, N2>::type
>{
> 
>};
>
>template<> struct lcm< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : lcm< T1 , T2 > { }; }; template< typename Tag > struct lambda< lcm< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef lcm< na , na > result_; typedef lcm< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< lcm< T1 , T2 > > : int_<2> { }; template<> struct template_arity< lcm< na , na > > : int_<-1> { }; }
>
>template<
> typename T
> , T n1
> , T n2
> >
>struct lcm_c
> : lcm<integral_c<T,n1>,integral_c<T,n2> >
>{
>};
>
>
>namespace aux {
>
>
>
>
> template< typename T1, boost::intmax_t n1, bool n1_is_0
> , typename T2, boost::intmax_t n2, bool n2_is_0 >
> struct lcm_aux
> : abs<integral_c< typename aux::largest_int<T1, T2>::type,
> ( n1 / gcd<integral_c<T1,n1>, integral_c<T2,n2> >::value * n2 )
> > >
> {};
>
> template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2>
> struct lcm_aux<T1, n1, false, T2, n2, true> : integral_c<T2, 0>
> {};
>
> template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2, bool C>
> struct lcm_aux<T1, n1, true, T2, n2, C> : integral_c<T1, 0>
> {};
># 112 "/usr/include/boost/ratio/detail/mpl/lcm.hpp" 3 4
>}
>
>template<>
>struct lcm_impl<integral_c_tag, integral_c_tag>
>{
> template< typename N1, typename N2 > struct apply
> : abs<aux::lcm_aux< typename N1::value_type, N1::value, N1::value==0,
> typename N2::value_type, N2::value, N2::value==0 > >
> {
> };
>};
>
>}}
># 40 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
># 1 "/usr/include/c++/4.8.2/cstdlib" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstdlib" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstdlib" 3
># 41 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
># 1 "/usr/include/c++/4.8.2/climits" 1 3 4
># 39 "/usr/include/c++/4.8.2/climits" 3 4
> 
># 40 "/usr/include/c++/4.8.2/climits" 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/climits" 2 3
># 42 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
>
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 44 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/integer_traits.hpp" 1 3 4
># 23 "/usr/include/boost/integer_traits.hpp" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
># 24 "/usr/include/boost/integer_traits.hpp" 2 3 4
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 28 "/usr/include/boost/integer_traits.hpp" 2 3 4
># 39 "/usr/include/boost/integer_traits.hpp" 3 4
> 
># 40 "/usr/include/boost/integer_traits.hpp" 3
>
>
>namespace boost {
>template<class T>
>class integer_traits : public std::numeric_limits<T>
>{
>public:
> static const bool is_integral = false;
>};
>
>namespace detail {
>template<class T, T min_val, T max_val>
>class integer_traits_base
>{
>public:
> static const bool is_integral = true;
> static const T const_min = min_val;
> static const T const_max = max_val;
>};
>
>
>
>template<class T, T min_val, T max_val>
>const bool integer_traits_base<T, min_val, max_val>::is_integral;
>
>template<class T, T min_val, T max_val>
>const T integer_traits_base<T, min_val, max_val>::const_min;
>
>template<class T, T min_val, T max_val>
>const T integer_traits_base<T, min_val, max_val>::const_max;
>
>
>}
>
>template<>
>class integer_traits<bool>
> : public std::numeric_limits<bool>,
> public detail::integer_traits_base<bool, false, true>
>{ };
>
>template<>
>class integer_traits<char>
> : public std::numeric_limits<char>,
> public detail::integer_traits_base<char, (-127 - 1), 127>
>{ };
>
>template<>
>class integer_traits<signed char>
> : public std::numeric_limits<signed char>,
> public detail::integer_traits_base<signed char, (-127 - 1), 127>
>{ };
>
>template<>
>class integer_traits<unsigned char>
> : public std::numeric_limits<unsigned char>,
> public detail::integer_traits_base<unsigned char, 0, (127 * 2 + 1)>
>{ };
>
>
>template<>
>class integer_traits<wchar_t>
> : public std::numeric_limits<wchar_t>,
>
>
>
> public detail::integer_traits_base<wchar_t, (-2147483647 - 1), 2147483647>
># 130 "/usr/include/boost/integer_traits.hpp" 3
>{ };
>
>
>template<>
>class integer_traits<short>
> : public std::numeric_limits<short>,
> public detail::integer_traits_base<short, (-32767 - 1), 32767>
>{ };
>
>template<>
>class integer_traits<unsigned short>
> : public std::numeric_limits<unsigned short>,
> public detail::integer_traits_base<unsigned short, 0, (32767 * 2 + 1)>
>{ };
>
>template<>
>class integer_traits<int>
> : public std::numeric_limits<int>,
> public detail::integer_traits_base<int, (-2147483647 - 1), 2147483647>
>{ };
>
>template<>
>class integer_traits<unsigned int>
> : public std::numeric_limits<unsigned int>,
> public detail::integer_traits_base<unsigned int, 0, (2147483647 * 2U + 1U)>
>{ };
>
>template<>
>class integer_traits<long>
> : public std::numeric_limits<long>,
> public detail::integer_traits_base<long, (-9223372036854775807L - 1L), 9223372036854775807L>
>{ };
>
>template<>
>class integer_traits<unsigned long>
> : public std::numeric_limits<unsigned long>,
> public detail::integer_traits_base<unsigned long, 0, (9223372036854775807L * 2UL + 1UL)>
>{ };
>
>
>
>
>template<>
>class integer_traits< ::boost::long_long_type>
> : public std::numeric_limits< ::boost::long_long_type>,
> public detail::integer_traits_base< ::boost::long_long_type, (-9223372036854775807LL -1), 9223372036854775807LL>
>{ };
>
>template<>
>class integer_traits< ::boost::ulong_long_type>
> : public std::numeric_limits< ::boost::ulong_long_type>,
> public detail::integer_traits_base< ::boost::ulong_long_type, 0, (9223372036854775807LL * 2ULL + 1)>
>{ };
># 256 "/usr/include/boost/integer_traits.hpp" 3
>}
># 47 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
># 1 "/usr/include/boost/ratio/ratio_fwd.hpp" 1 3 4
># 37 "/usr/include/boost/ratio/ratio_fwd.hpp" 3 4
>namespace boost
>{
># 47 "/usr/include/boost/ratio/ratio_fwd.hpp" 3 4
>template <boost::intmax_t N, boost::intmax_t D = 1> class ratio;
>
>
>template <class R1, class R2> struct ratio_add;
>template <class R1, class R2> struct ratio_subtract;
>template <class R1, class R2> struct ratio_multiply;
>template <class R1, class R2> struct ratio_divide;
>
>
>template <class R1, class R2> struct ratio_equal;
>template <class R1, class R2> struct ratio_not_equal;
>template <class R1, class R2> struct ratio_less;
>template <class R1, class R2> struct ratio_less_equal;
>template <class R1, class R2> struct ratio_greater;
>template <class R1, class R2> struct ratio_greater_equal;
>
>
>typedef ratio<1L, 1000000000000000000L> atto;
>typedef ratio<1L, 1000000000000000L> femto;
>typedef ratio<1L, 1000000000000L> pico;
>typedef ratio<1L, 1000000000L> nano;
>typedef ratio<1L, 1000000L> micro;
>typedef ratio<1L, 1000L> milli;
>typedef ratio<1L, 100L> centi;
>typedef ratio<1L, 10L> deci;
>typedef ratio< 10L, 1L> deca;
>typedef ratio< 100L, 1L> hecto;
>typedef ratio< 1000L, 1L> kilo;
>typedef ratio< 1000000L, 1L> mega;
>typedef ratio< 1000000000L, 1L> giga;
>typedef ratio< 1000000000000L, 1L> tera;
>typedef ratio< 1000000000000000L, 1L> peta;
>typedef ratio<1000000000000000000L, 1L> exa;
>
>}
># 48 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
># 1 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 1 3 4
># 38 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstdlib" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstdlib" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstdlib" 3
># 39 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 2 3 4
># 1 "/usr/include/c++/4.8.2/climits" 1 3 4
># 39 "/usr/include/c++/4.8.2/climits" 3 4
> 
># 40 "/usr/include/c++/4.8.2/climits" 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/climits" 2 3
># 40 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 2 3 4
>
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 42 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 2 3 4
># 55 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 3 4
> 
># 56 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 3
>
>
>namespace boost
>{
>
>
>
>
>
>namespace ratio_detail
>{
>
> template <boost::intmax_t X, boost::intmax_t Y, boost::intmax_t = mpl::sign_c<boost::intmax_t, Y>::value>
> class br_add;
>
> template <boost::intmax_t X, boost::intmax_t Y>
> class br_add<X, Y, 1>
> {
> static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
> static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
>
> static_assert(X <= max - Y,"overflow in ratio add");
> public:
> static const boost::intmax_t value = X + Y;
> };
>
> template <boost::intmax_t X, boost::intmax_t Y>
> class br_add<X, Y, 0>
> {
> public:
> static const boost::intmax_t value = X;
> };
>
> template <boost::intmax_t X, boost::intmax_t Y>
> class br_add<X, Y, -1>
> {
> static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
> static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
>
> static_assert(min - Y <= X,"overflow in ratio add");
> public:
> static const boost::intmax_t value = X + Y;
> };
>
> template <boost::intmax_t X, boost::intmax_t Y, boost::intmax_t = mpl::sign_c<boost::intmax_t, Y>::value>
> class br_sub;
>
> template <boost::intmax_t X, boost::intmax_t Y>
> class br_sub<X, Y, 1>
> {
> static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
> static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
>
> static_assert(min + Y <= X,"overflow in ratio sub");
> public:
> static const boost::intmax_t value = X - Y;
> };
>
> template <boost::intmax_t X, boost::intmax_t Y>
> class br_sub<X, Y, 0>
> {
> public:
> static const boost::intmax_t value = X;
> };
>
> template <boost::intmax_t X, boost::intmax_t Y>
> class br_sub<X, Y, -1>
> {
> static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
> static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
>
> static_assert(X <= max + Y,"overflow in ratio sub");
> public:
> static const boost::intmax_t value = X - Y;
> };
>
> template <boost::intmax_t X, boost::intmax_t Y>
> class br_mul
> {
> static const boost::intmax_t nan =
> boost::intmax_t(1UL << (sizeof(boost::intmax_t) * 8 - 1));
> static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
> static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
>
> static const boost::intmax_t a_x = mpl::abs_c<boost::intmax_t, X>::value;
> static const boost::intmax_t a_y = mpl::abs_c<boost::intmax_t, Y>::value;
>
> static_assert(X != nan,"overflow in ratio mul");
> static_assert(Y != nan,"overflow in ratio mul");
> static_assert(a_x <= max / a_y,"overflow in ratio mul");
> public:
> static const boost::intmax_t value = X * Y;
> };
>
> template <boost::intmax_t Y>
> class br_mul<0, Y>
> {
> public:
> static const boost::intmax_t value = 0;
> };
>
> template <boost::intmax_t X>
> class br_mul<X, 0>
> {
> public:
> static const boost::intmax_t value = 0;
> };
>
> template <>
> class br_mul<0, 0>
> {
> public:
> static const boost::intmax_t value = 0;
> };
>
>
> template <boost::intmax_t X, boost::intmax_t Y>
> class br_div
> {
> static const boost::intmax_t nan = boost::intmax_t(1UL << (sizeof(boost::intmax_t) * 8 - 1));
> static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
> static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
>
> static_assert(X != nan,"overflow in ratio div");
> static_assert(Y != nan,"overflow in ratio div");
> static_assert(Y != 0,"ratio divide by 0");
> public:
> static const boost::intmax_t value = X / Y;
> };
>
>
> template <class R1, class R2> struct ratio_add;
> template <class R1, class R2> struct ratio_subtract;
> template <class R1, class R2> struct ratio_multiply;
> template <class R1, class R2> struct ratio_divide;
>
> template <class R1, class R2>
> struct ratio_add
> {
>
>
>
> private:
> static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
> static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
> public:
>
> typedef typename ratio_multiply
> <
> ratio<gcd_n1_n2, R1::den / gcd_d1_d2>,
> ratio
> <
> boost::ratio_detail::br_add
> <
> boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
> boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
> >::value,
> R2::den
> >
> >::type type;
> };
> template <class R, boost::intmax_t D>
> struct ratio_add<R, ratio<0,D> >
> {
> typedef R type;
> };
>
> template <class R1, class R2>
> struct ratio_subtract
> {
>
>
>
> private:
> static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
> static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
> public:
>
> typedef typename ratio_multiply
> <
> ratio<gcd_n1_n2, R1::den / gcd_d1_d2>,
> ratio
> <
> boost::ratio_detail::br_sub
> <
> boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
> boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
> >::value,
> R2::den
> >
> >::type type;
> };
>
> template <class R, boost::intmax_t D>
> struct ratio_subtract<R, ratio<0,D> >
> {
> typedef R type;
> };
>
> template <class R1, class R2>
> struct ratio_multiply
> {
>
>
> private:
> static const boost::intmax_t gcd_n1_d2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::den>::value;
> static const boost::intmax_t gcd_d1_n2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::num>::value;
> public:
> typedef typename ratio
> <
> boost::ratio_detail::br_mul<R1::num / gcd_n1_d2, R2::num / gcd_d1_n2>::value,
> boost::ratio_detail::br_mul<R2::den / gcd_n1_d2, R1::den / gcd_d1_n2>::value
> >::type type;
> };
>
> template <class R1, class R2>
> struct ratio_divide
> {
>
>
> private:
> static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
> static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
> public:
> typedef typename ratio
> <
> boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
> boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
> >::type type;
> };
> template <class R1, class R2>
> struct is_evenly_divisible_by
> {
> private:
> static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
> static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
> public:
> typedef integral_constant<bool,
> ((R2::num / gcd_n1_n2 ==1) && (R1::den / gcd_d1_d2)==1)
> > type;
> };
>
> template <class T>
> struct is_ratio : public boost::false_type
> {};
> template <boost::intmax_t N, boost::intmax_t D>
> struct is_ratio<ratio<N, D> > : public boost::true_type
> {};
>
> template <class R1, class R2,
> boost::intmax_t Q1 = R1::num / R1::den, boost::intmax_t M1 = R1::num % R1::den,
> boost::intmax_t Q2 = R2::num / R2::den, boost::intmax_t M2 = R2::num % R2::den>
> struct ratio_less1
> {
> static const bool value = Q1 < Q2;
> };
>
> template <class R1, class R2, boost::intmax_t Q>
> struct ratio_less1<R1, R2, Q, 0, Q, 0>
> {
> static const bool value = false;
> };
>
> template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M2>
> struct ratio_less1<R1, R2, Q, 0, Q, M2>
> {
> static const bool value = true;
> };
>
> template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M1>
> struct ratio_less1<R1, R2, Q, M1, Q, 0>
> {
> static const bool value = false;
> };
>
> template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M1, boost::intmax_t M2>
> struct ratio_less1<R1, R2, Q, M1, Q, M2>
> {
> static const bool value = ratio_less1<ratio<R2::den, M2>, ratio<R1::den, M1>
> >::value;
> };
>
> template <
> class R1,
> class R2,
> boost::intmax_t S1 = mpl::sign_c<boost::intmax_t, R1::num>::value,
> boost::intmax_t S2 = mpl::sign_c<boost::intmax_t, R2::num>::value
>>
> struct ratio_less
> {
> static const bool value = S1 < S2;
> };
>
> template <class R1, class R2>
> struct ratio_less<R1, R2, 1LL, 1LL>
> {
> static const bool value = ratio_less1<R1, R2>::value;
> };
>
> template <class R1, class R2>
> struct ratio_less<R1, R2, -1LL, -1LL>
> {
> static const bool value = ratio_less1<ratio<-R2::num, R2::den>,
> ratio<-R1::num, R1::den> >::value;
> };
>
>
>}
>
>}
># 49 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
># 63 "/usr/include/boost/ratio/ratio.hpp" 3 4
> 
># 64 "/usr/include/boost/ratio/ratio.hpp" 3
>
>
>namespace boost
>{
># 76 "/usr/include/boost/ratio/ratio.hpp" 3
>template <boost::intmax_t N, boost::intmax_t D>
>class ratio
>{
> static const boost::intmax_t ABS_N = mpl::abs_c<boost::intmax_t, N>::value;
> static const boost::intmax_t ABS_D = mpl::abs_c<boost::intmax_t, D>::value;
> static_assert(ABS_N >= 0,"ratio numerator is out of range");
> static_assert(ABS_D > 0,"ratio denominator is out of range");
> static_assert(D != 0,"ratio divide by 0");
> static const boost::intmax_t SIGN_N = mpl::sign_c<boost::intmax_t,N>::value
> * mpl::sign_c<boost::intmax_t,D>::value;
> static const boost::intmax_t GCD = mpl::gcd_c<boost::intmax_t, ABS_N, ABS_D>::value;
>public:
> static constexpr boost::intmax_t num = SIGN_N * ABS_N / GCD;
> static constexpr boost::intmax_t den = ABS_D / GCD;
># 119 "/usr/include/boost/ratio/ratio.hpp" 3
> typedef ratio<num, den> type;
>};
># 135 "/usr/include/boost/ratio/ratio.hpp" 3
>template <class R1, class R2>
>struct ratio_add
>: boost::ratio_detail::ratio_add<R1, R2>::type
>{
>};
>
>template <class R1, class R2>
>struct ratio_subtract
>: boost::ratio_detail::ratio_subtract<R1, R2>::type
>{
>};
>
>template <class R1, class R2>
>struct ratio_multiply
>: boost::ratio_detail::ratio_multiply<R1, R2>::type
>{
>};
>
>template <class R1, class R2>
>struct ratio_divide
>: boost::ratio_detail::ratio_divide<R1, R2>::type
>{
>};
># 167 "/usr/include/boost/ratio/ratio.hpp" 3
>template <class R1, class R2>
>struct ratio_equal
> : public boost::integral_constant<bool,
> (R1::num == R2::num && R1::den == R2::den)>
>{};
>
>template <class R1, class R2>
>struct ratio_not_equal
> : public boost::integral_constant<bool, !ratio_equal<R1, R2>::value>
>{};
>
>
>
>template <class R1, class R2>
>struct ratio_less
> : boost::integral_constant<bool, boost::ratio_detail::ratio_less<R1, R2>::value>
>{};
>
>template <class R1, class R2>
>struct ratio_less_equal
> : boost::integral_constant<bool, !ratio_less<R2, R1>::value>
>{};
>
>template <class R1, class R2>
>struct ratio_greater
> : boost::integral_constant<bool, ratio_less<R2, R1>::value>
>{};
>
>template <class R1, class R2>
>struct ratio_greater_equal
> : boost::integral_constant<bool, !ratio_less<R1, R2>::value>
>{};
>
>template <class R1, class R2>
>struct ratio_gcd :
> ratio<mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value,
> mpl::lcm_c<boost::intmax_t, R1::den, R2::den>::value>::type
>{
>};
># 230 "/usr/include/boost/ratio/ratio.hpp" 3
>}
># 42 "/usr/include/boost/chrono/duration.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/chrono/detail/is_evenly_divisible_by.hpp" 1 3 4
># 16 "/usr/include/boost/chrono/detail/is_evenly_divisible_by.hpp" 3 4
>namespace boost {
>namespace chrono {
>namespace chrono_detail {
>
>
>
>
> template <class R1, class R2>
> struct is_evenly_divisible_by : public boost::ratio_detail::is_evenly_divisible_by<R1, R2>
> {};
>
>}
>}
>}
># 48 "/usr/include/boost/chrono/duration.hpp" 2 3 4
>
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 50 "/usr/include/boost/chrono/duration.hpp" 2 3 4
># 63 "/usr/include/boost/chrono/duration.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 64 "/usr/include/boost/chrono/duration.hpp" 2 3 4
># 73 "/usr/include/boost/chrono/duration.hpp" 3 4
>namespace boost {
>namespace chrono {
>
> template <class Rep, class Period = ratio<1> >
> class duration;
>
> namespace detail
> {
> template <class T>
> struct is_duration
> : boost::false_type {};
>
> template <class Rep, class Period>
> struct is_duration<duration<Rep, Period> >
> : boost::true_type {};
>
> template <class Duration, class Rep, bool = is_duration<Rep>::value>
> struct duration_divide_result
> {
> };
>
> template <class Duration, class Rep2,
> bool = (
> ((boost::is_convertible<typename Duration::rep,
> typename common_type<typename Duration::rep, Rep2>::type>::value))
> && ((boost::is_convertible<Rep2,
> typename common_type<typename Duration::rep, Rep2>::type>::value))
> )
> >
> struct duration_divide_imp
> {
> };
>
> template <class Rep1, class Period, class Rep2>
> struct duration_divide_imp<duration<Rep1, Period>, Rep2, true>
> {
> typedef duration<typename common_type<Rep1, Rep2>::type, Period> type;
> };
>
> template <class Rep1, class Period, class Rep2>
> struct duration_divide_result<duration<Rep1, Period>, Rep2, false>
> : duration_divide_imp<duration<Rep1, Period>, Rep2>
> {
> };
>
>
> template <class Rep, class Duration, bool = is_duration<Rep>::value>
> struct duration_divide_result2
> {
> };
>
> template <class Rep, class Duration,
> bool = (
> ((boost::is_convertible<typename Duration::rep,
> typename common_type<typename Duration::rep, Rep>::type>::value))
> && ((boost::is_convertible<Rep,
> typename common_type<typename Duration::rep, Rep>::type>::value))
> )
> >
> struct duration_divide_imp2
> {
> };
>
> template <class Rep1, class Rep2, class Period >
> struct duration_divide_imp2<Rep1, duration<Rep2, Period>, true>
> {
>
> typedef double type;
> };
>
> template <class Rep1, class Rep2, class Period >
> struct duration_divide_result2<Rep1, duration<Rep2, Period>, false>
> : duration_divide_imp2<Rep1, duration<Rep2, Period> >
> {
> };
>
>
> template <class Duration, class Rep, bool = is_duration<Rep>::value>
> struct duration_modulo_result
> {
> };
>
> template <class Duration, class Rep2,
> bool = (
>
>
>
> boost::is_convertible<Rep2,
> typename common_type<typename Duration::rep, Rep2>::type>::value
> )
> >
> struct duration_modulo_imp
> {
> };
>
> template <class Rep1, class Period, class Rep2>
> struct duration_modulo_imp<duration<Rep1, Period>, Rep2, true>
> {
> typedef duration<typename common_type<Rep1, Rep2>::type, Period> type;
> };
>
> template <class Rep1, class Period, class Rep2>
> struct duration_modulo_result<duration<Rep1, Period>, Rep2, false>
> : duration_modulo_imp<duration<Rep1, Period>, Rep2>
> {
> };
>
>}
>}
>
>
>
>
>template <class Rep1, class Period1, class Rep2, class Period2>
>struct common_type<chrono::duration<Rep1, Period1>,
> chrono::duration<Rep2, Period2> >;
>
>
>namespace chrono {
>
>
> template <class Rep> struct treat_as_floating_point;
> template <class Rep> struct duration_values;
>
>
> typedef duration<boost::int_least64_t, nano> nanoseconds;
> typedef duration<boost::int_least64_t, micro> microseconds;
> typedef duration<boost::int_least64_t, milli> milliseconds;
> typedef duration<boost::int_least64_t> seconds;
> typedef duration<boost::int_least32_t, ratio< 60> > minutes;
> typedef duration<boost::int_least32_t, ratio<3600> > hours;
>
>
>
>
>
>namespace detail
>{
># 223 "/usr/include/boost/chrono/duration.hpp" 3 4
> template <class FromDuration, class ToDuration,
> class Period,
> bool PeriodNumEq1,
> bool PeriodDenEq1>
> struct duration_cast_aux;
>
>
>
>
>
> template <class FromDuration, class ToDuration, class Period>
> struct duration_cast_aux<FromDuration, ToDuration, Period, true, true>
> {
> constexpr ToDuration operator()(const FromDuration& fd) const
> {
> return ToDuration(static_cast<typename ToDuration::rep>(fd.count()));
> }
> };
>
>
>
>
>
>
>
> template <class FromDuration, class ToDuration, class Period>
> struct duration_cast_aux<FromDuration, ToDuration, Period, true, false>
> {
> constexpr ToDuration operator()(const FromDuration& fd) const
> {
> typedef typename common_type<
> typename ToDuration::rep,
> typename FromDuration::rep,
> boost::intmax_t>::type C;
> return ToDuration(static_cast<typename ToDuration::rep>(
> static_cast<C>(fd.count()) / static_cast<C>(Period::den)));
> }
> };
>
>
>
>
>
>
> template <class FromDuration, class ToDuration, class Period>
> struct duration_cast_aux<FromDuration, ToDuration, Period, false, true>
> {
> constexpr ToDuration operator()(const FromDuration& fd) const
> {
> typedef typename common_type<
> typename ToDuration::rep,
> typename FromDuration::rep,
> boost::intmax_t>::type C;
> return ToDuration(static_cast<typename ToDuration::rep>(
> static_cast<C>(fd.count()) * static_cast<C>(Period::num)));
> }
> };
>
>
>
>
>
>
>
> template <class FromDuration, class ToDuration, class Period>
> struct duration_cast_aux<FromDuration, ToDuration, Period, false, false>
> {
> constexpr ToDuration operator()(const FromDuration& fd) const
> {
> typedef typename common_type<
> typename ToDuration::rep,
> typename FromDuration::rep,
> boost::intmax_t>::type C;
> return ToDuration(static_cast<typename ToDuration::rep>(
> static_cast<C>(fd.count()) * static_cast<C>(Period::num)
> / static_cast<C>(Period::den)));
> }
> };
>
> template <class FromDuration, class ToDuration>
> struct duration_cast {
> typedef typename ratio_divide<typename FromDuration::period,
> typename ToDuration::period>::type Period;
> typedef duration_cast_aux<
> FromDuration,
> ToDuration,
> Period,
> Period::num == 1,
> Period::den == 1
> > Aux;
> constexpr ToDuration operator()(const FromDuration& fd) const
> {
> return Aux()(fd);
> }
> };
>
>}
># 333 "/usr/include/boost/chrono/duration.hpp" 3 4
> template <class Rep>
> struct treat_as_floating_point : boost::is_floating_point<Rep> {};
>
>
>
>
>
>namespace detail {
> template <class T, bool = is_arithmetic<T>::value>
> struct chrono_numeric_limits {
> static constexpr T lowest() noexcept {return (std::numeric_limits<T>::min) ();}
> };
>
> template <class T>
> struct chrono_numeric_limits<T,true> {
> static constexpr T lowest() noexcept {return (std::numeric_limits<T>::min) ();}
> };
>
> template <>
> struct chrono_numeric_limits<float,true> {
> static constexpr float lowest() noexcept
> {
> return -(std::numeric_limits<float>::max) ();
> }
> };
>
> template <>
> struct chrono_numeric_limits<double,true> {
> static constexpr double lowest() noexcept
> {
> return -(std::numeric_limits<double>::max) ();
> }
> };
>
> template <>
> struct chrono_numeric_limits<long double,true> {
> static constexpr long double lowest() noexcept
> {
> return -(std::numeric_limits<long double>::max)();
> }
> };
>
> template <class T>
> struct numeric_limits : chrono_numeric_limits<typename remove_cv<T>::type>
> {};
>
>}
>template <class Rep>
>struct duration_values
>{
> static constexpr Rep zero() {return Rep(0);}
> static constexpr Rep max ()
> {
> return (std::numeric_limits<Rep>::max)();
> }
>
> static constexpr Rep min ()
> {
> return detail::numeric_limits<Rep>::lowest();
> }
>};
>
>}
>
>
>
>
>
>template <class Rep1, class Period1, class Rep2, class Period2>
>struct common_type<chrono::duration<Rep1, Period1>,
> chrono::duration<Rep2, Period2> >
>{
> typedef chrono::duration<typename common_type<Rep1, Rep2>::type,
> typename boost::ratio_gcd<Period1, Period2>::type> type;
>};
># 417 "/usr/include/boost/chrono/duration.hpp" 3 4
>namespace chrono {
>
> template <class Rep, class Period>
> class __attribute__((__visibility__("default"))) duration
> {
>
> static_assert(!boost::chrono::detail::is_duration<Rep>::value,"A duration representation can not be a duration")
> ;
> static_assert(boost::ratio_detail::is_ratio<typename Period::type>::value,"Second template parameter of duration must be a boost::ratio")
> ;
> static_assert(Period::num>0,"duration period must be positive")
> ;
> public:
> typedef Rep rep;
> typedef Period period;
> private:
> rep rep_;
> public:
>
> inline __attribute__ ((__always_inline__)) constexpr
> duration() : rep_(duration_values<rep>::zero()) { }
> template <class Rep2>
> __attribute__((__visibility__("default"))) inline __attribute__ ((__always_inline__)) constexpr
> explicit duration(const Rep2& r
> , typename boost::enable_if <
> mpl::and_ <
> boost::is_convertible<Rep2, rep>,
> mpl::or_ <
> treat_as_floating_point<rep>,
> mpl::and_ <
> mpl::not_ < treat_as_floating_point<rep> >,
> mpl::not_ < treat_as_floating_point<Rep2> >
> >
> >
> >
> >::type* = 0
> ) : rep_(r) { }
>
>
> duration& operator=(const duration& rhs)
> {
> if (&rhs != this) rep_= rhs.rep_;
> return *this;
> }
>
>
> template <class Rep2, class Period2>
> inline __attribute__ ((__always_inline__)) constexpr
> duration(const duration<Rep2, Period2>& d
> , typename boost::enable_if <
> mpl::or_ <
> treat_as_floating_point<rep>,
> mpl::and_ <
> chrono_detail::is_evenly_divisible_by<Period2, period>,
> mpl::not_ < treat_as_floating_point<Rep2> >
> >
> >
> >::type* = 0
> )
> : rep_(chrono::detail::duration_cast<duration<Rep2, Period2>, duration>()(d).count()) {}
>
>
>
> constexpr
> rep count() const {return rep_;}
>
>
>
> constexpr
> duration operator+() const {return duration(rep_);;}
> constexpr
> duration operator-() const {return duration(-rep_);}
> duration& operator++() {++rep_; return *this;}
> duration operator++(int) {return duration(rep_++);}
> duration& operator--() {--rep_; return *this;}
> duration operator--(int) {return duration(rep_--);}
>
> duration& operator+=(const duration& d)
> {
> rep_ += d.count(); return *this;
> }
> duration& operator-=(const duration& d)
> {
> rep_ -= d.count(); return *this;
> }
>
> duration& operator*=(const rep& rhs) {rep_ *= rhs; return *this;}
> duration& operator/=(const rep& rhs) {rep_ /= rhs; return *this;}
> duration& operator%=(const rep& rhs) {rep_ %= rhs; return *this;}
> duration& operator%=(const duration& rhs)
> {
> rep_ %= rhs.count(); return *this;
> }
>
>
> static constexpr duration zero()
> {
> return duration(duration_values<rep>::zero());
> }
> static constexpr duration min ()
> {
> return duration((duration_values<rep>::min)());
> }
> static constexpr duration max ()
> {
> return duration((duration_values<rep>::max)());
> }
> };
>
>
>
>
>
>
>
> template <class Rep1, class Period1, class Rep2, class Period2>
> inline constexpr
> typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
> operator+(const duration<Rep1, Period1>& lhs,
> const duration<Rep2, Period2>& rhs)
> {
> typedef typename common_type<duration<Rep1, Period1>,
> duration<Rep2, Period2> >::type CD;
> return CD(CD(lhs).count()+CD(rhs).count());
> }
>
>
>
> template <class Rep1, class Period1, class Rep2, class Period2>
> inline constexpr
> typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
> operator-(const duration<Rep1, Period1>& lhs,
> const duration<Rep2, Period2>& rhs)
> {
> typedef typename common_type<duration<Rep1, Period1>,
> duration<Rep2, Period2> >::type CD;
> return CD(CD(lhs).count()-CD(rhs).count());
> }
>
>
>
> template <class Rep1, class Period, class Rep2>
> inline constexpr
> typename boost::enable_if <
> mpl::and_ <
> boost::is_convertible<Rep1, typename common_type<Rep1, Rep2>::type>,
> boost::is_convertible<Rep2, typename common_type<Rep1, Rep2>::type>
> >,
> duration<typename common_type<Rep1, Rep2>::type, Period>
> >::type
> operator*(const duration<Rep1, Period>& d, const Rep2& s)
> {
> typedef typename common_type<Rep1, Rep2>::type CR;
> typedef duration<CR, Period> CD;
> return CD(CD(d).count()*static_cast<CR>(s));
> }
>
> template <class Rep1, class Period, class Rep2>
> inline constexpr
> typename boost::enable_if <
> mpl::and_ <
> boost::is_convertible<Rep1, typename common_type<Rep1, Rep2>::type>,
> boost::is_convertible<Rep2, typename common_type<Rep1, Rep2>::type>
> >,
> duration<typename common_type<Rep1, Rep2>::type, Period>
> >::type
> operator*(const Rep1& s, const duration<Rep2, Period>& d)
> {
> return d * s;
> }
>
>
>
> template <class Rep1, class Period, class Rep2>
> inline constexpr
> typename boost::disable_if <boost::chrono::detail::is_duration<Rep2>,
> typename boost::chrono::detail::duration_divide_result<
> duration<Rep1, Period>, Rep2>::type
> >::type
> operator/(const duration<Rep1, Period>& d, const Rep2& s)
> {
> typedef typename common_type<Rep1, Rep2>::type CR;
> typedef duration<CR, Period> CD;
>
> return CD(CD(d).count()/static_cast<CR>(s));
> }
>
> template <class Rep1, class Period1, class Rep2, class Period2>
> inline constexpr
> typename common_type<Rep1, Rep2>::type
> operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
> {
> typedef typename common_type<duration<Rep1, Period1>,
> duration<Rep2, Period2> >::type CD;
> return CD(lhs).count() / CD(rhs).count();
> }
># 631 "/usr/include/boost/chrono/duration.hpp" 3 4
> template <class Rep1, class Period, class Rep2>
> inline constexpr
> typename boost::disable_if <boost::chrono::detail::is_duration<Rep2>,
> typename boost::chrono::detail::duration_modulo_result<
> duration<Rep1, Period>, Rep2>::type
> >::type
> operator%(const duration<Rep1, Period>& d, const Rep2& s)
> {
> typedef typename common_type<Rep1, Rep2>::type CR;
> typedef duration<CR, Period> CD;
>
> return CD(CD(d).count()%static_cast<CR>(s));
> }
>
> template <class Rep1, class Period1, class Rep2, class Period2>
> inline constexpr
> typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
> operator%(const duration<Rep1, Period1>& lhs,
> const duration<Rep2, Period2>& rhs) {
> typedef typename common_type<duration<Rep1, Period1>,
> duration<Rep2, Period2> >::type CD;
>
> return CD(CD(lhs).count()%CD(rhs).count());
> }
>
>
>
>
>
>
>namespace detail
>{
> template <class LhsDuration, class RhsDuration>
> struct duration_eq
> {
> constexpr bool operator()(const LhsDuration& lhs, const RhsDuration& rhs) const
> {
> typedef typename common_type<LhsDuration, RhsDuration>::type CD;
> return CD(lhs).count() == CD(rhs).count();
> }
> };
>
> template <class LhsDuration>
> struct duration_eq<LhsDuration, LhsDuration>
> {
> constexpr bool operator()(const LhsDuration& lhs, const LhsDuration& rhs) const
> {
> return lhs.count() == rhs.count();
> }
> };
>
> template <class LhsDuration, class RhsDuration>
> struct duration_lt
> {
> constexpr bool operator()(const LhsDuration& lhs, const RhsDuration& rhs) const
> {
> typedef typename common_type<LhsDuration, RhsDuration>::type CD;
> return CD(lhs).count() < CD(rhs).count();
> }
> };
>
> template <class LhsDuration>
> struct duration_lt<LhsDuration, LhsDuration>
> {
> constexpr bool operator()(const LhsDuration& lhs, const LhsDuration& rhs) const
> {
> return lhs.count() < rhs.count();
> }
> };
>
>}
>
>
>
> template <class Rep1, class Period1, class Rep2, class Period2>
> inline constexpr
> bool
> operator==(const duration<Rep1, Period1>& lhs,
> const duration<Rep2, Period2>& rhs)
> {
> return boost::chrono::detail::duration_eq<
> duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs);
> }
>
>
>
> template <class Rep1, class Period1, class Rep2, class Period2>
> inline constexpr
> bool
> operator!=(const duration<Rep1, Period1>& lhs,
> const duration<Rep2, Period2>& rhs)
> {
> return !(lhs == rhs);
> }
>
>
>
> template <class Rep1, class Period1, class Rep2, class Period2>
> inline constexpr
> bool
> operator< (const duration<Rep1, Period1>& lhs,
> const duration<Rep2, Period2>& rhs)
> {
> return boost::chrono::detail::duration_lt<
> duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs);
> }
>
>
>
> template <class Rep1, class Period1, class Rep2, class Period2>
> inline constexpr
> bool
> operator> (const duration<Rep1, Period1>& lhs,
> const duration<Rep2, Period2>& rhs)
> {
> return rhs < lhs;
> }
>
>
>
> template <class Rep1, class Period1, class Rep2, class Period2>
> inline constexpr
> bool
> operator<=(const duration<Rep1, Period1>& lhs,
> const duration<Rep2, Period2>& rhs)
> {
> return !(rhs < lhs);
> }
>
>
>
> template <class Rep1, class Period1, class Rep2, class Period2>
> inline constexpr
> bool
> operator>=(const duration<Rep1, Period1>& lhs,
> const duration<Rep2, Period2>& rhs)
> {
> return !(lhs < rhs);
> }
>
>
>
>
>
>
> template <class ToDuration, class Rep, class Period>
> inline constexpr
> typename boost::enable_if <
> boost::chrono::detail::is_duration<ToDuration>, ToDuration>::type
> duration_cast(const duration<Rep, Period>& fd)
> {
> return boost::chrono::detail::duration_cast<
> duration<Rep, Period>, ToDuration>()(fd);
> }
>
>}
>}
>
>
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 792 "/usr/include/boost/chrono/duration.hpp" 2 3 4
># 34 "/usr/include/boost/chrono/time_point.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 39 "/usr/include/boost/chrono/time_point.hpp" 2 3 4
># 48 "/usr/include/boost/chrono/time_point.hpp" 3 4
>namespace boost {
>namespace chrono {
>
> template <class Clock, class Duration = typename Clock::duration>
> class time_point;
>
>
>}
>
>
>
>
>template <class Clock, class Duration1, class Duration2>
> struct common_type<chrono::time_point<Clock, Duration1>,
> chrono::time_point<Clock, Duration2> >;
>
>
>
>
>
>
>
>template <class Clock, class Duration1, class Duration2>
>struct common_type<chrono::time_point<Clock, Duration1>,
> chrono::time_point<Clock, Duration2> >
>{
> typedef chrono::time_point<Clock,
> typename common_type<Duration1, Duration2>::type> type;
>};
>
>
>
>namespace chrono {
>
>
> template <class Clock, class Duration1, class Rep2, class Period2>
> inline constexpr
> time_point<Clock,
> typename common_type<Duration1, duration<Rep2, Period2> >::type>
> operator+(
> const time_point<Clock, Duration1>& lhs,
> const duration<Rep2, Period2>& rhs);
> template <class Rep1, class Period1, class Clock, class Duration2>
> inline constexpr
> time_point<Clock,
> typename common_type<duration<Rep1, Period1>, Duration2>::type>
> operator+(
> const duration<Rep1, Period1>& lhs,
> const time_point<Clock, Duration2>& rhs);
> template <class Clock, class Duration1, class Rep2, class Period2>
> inline constexpr
> time_point<Clock,
> typename common_type<Duration1, duration<Rep2, Period2> >::type>
> operator-(
> const time_point<Clock, Duration1>& lhs,
> const duration<Rep2, Period2>& rhs);
> template <class Clock, class Duration1, class Duration2>
> inline constexpr
> typename common_type<Duration1, Duration2>::type
> operator-(
> const time_point<Clock, Duration1>& lhs,
> const time_point<Clock,
> Duration2>& rhs);
>
>
> template <class Clock, class Duration1, class Duration2>
> inline constexpr
> bool operator==(
> const time_point<Clock, Duration1>& lhs,
> const time_point<Clock, Duration2>& rhs);
> template <class Clock, class Duration1, class Duration2>
> inline constexpr
> bool operator!=(
> const time_point<Clock, Duration1>& lhs,
> const time_point<Clock, Duration2>& rhs);
> template <class Clock, class Duration1, class Duration2>
> inline constexpr
> bool operator< (
> const time_point<Clock, Duration1>& lhs,
> const time_point<Clock, Duration2>& rhs);
> template <class Clock, class Duration1, class Duration2>
> inline constexpr
> bool operator<=(
> const time_point<Clock, Duration1>& lhs,
> const time_point<Clock, Duration2>& rhs);
> template <class Clock, class Duration1, class Duration2>
> inline constexpr
> bool operator> (
> const time_point<Clock, Duration1>& lhs,
> const time_point<Clock, Duration2>& rhs);
> template <class Clock, class Duration1, class Duration2>
> inline constexpr
> bool operator>=(
> const time_point<Clock, Duration1>& lhs,
> const time_point<Clock, Duration2>& rhs);
>
>
> template <class ToDuration, class Clock, class Duration>
> inline constexpr
> time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
>
>
>
>
>
>
>
> template <class Clock, class Duration>
> class time_point
> {
> static_assert(boost::chrono::detail::is_duration<Duration>::value,"Second template parameter of time_point must be a boost::chrono::duration")
> ;
> public:
> typedef Clock clock;
> typedef Duration duration;
> typedef typename duration::rep rep;
> typedef typename duration::period period;
> typedef Duration difference_type;
>
> private:
> duration d_;
>
> public:
> inline __attribute__ ((__always_inline__)) constexpr
> time_point() : d_(duration::zero())
> {}
> inline __attribute__ ((__always_inline__)) constexpr
> explicit time_point(const duration& d)
> : d_(d)
> {}
>
>
> template <class Duration2>
> inline __attribute__ ((__always_inline__)) constexpr
> time_point(const time_point<clock, Duration2>& t
> , typename boost::enable_if
> <
> boost::is_convertible<Duration2, duration>
> >::type* = 0
> )
> : d_(t.time_since_epoch())
> {
> }
>
>
> constexpr
> duration time_since_epoch() const
> {
> return d_;
> }
># 216 "/usr/include/boost/chrono/time_point.hpp" 3 4
> time_point& operator+=(const duration& d) {d_ += d; return *this;}
> time_point& operator-=(const duration& d) {d_ -= d; return *this;}
>
>
>
> static constexpr time_point
> min ()
> {
> return time_point((duration::min)());
> }
> static constexpr time_point
> max ()
> {
> return time_point((duration::max)());
> }
> };
>
>
>
>
>
>
>
> template <class Clock, class Duration1, class Rep2, class Period2>
> inline constexpr
> time_point<Clock,
> typename common_type<Duration1, duration<Rep2, Period2> >::type>
> operator+(const time_point<Clock, Duration1>& lhs,
> const duration<Rep2, Period2>& rhs)
> {
> typedef typename common_type<Duration1, duration<Rep2, Period2> >::type CDuration;
> typedef time_point<
> Clock,
> CDuration
> > TimeResult;
> return TimeResult(lhs.time_since_epoch() + CDuration(rhs));
> }
>
>
>
> template <class Rep1, class Period1, class Clock, class Duration2>
> inline constexpr
> time_point<Clock,
> typename common_type<duration<Rep1, Period1>, Duration2>::type>
> operator+(const duration<Rep1, Period1>& lhs,
> const time_point<Clock, Duration2>& rhs)
> {
> return rhs + lhs;
> }
>
>
>
> template <class Clock, class Duration1, class Rep2, class Period2>
> inline constexpr
> time_point<Clock,
> typename common_type<Duration1, duration<Rep2, Period2> >::type>
> operator-(const time_point<Clock, Duration1>& lhs,
> const duration<Rep2, Period2>& rhs)
> {
> return lhs + (-rhs);
> }
>
>
>
> template <class Clock, class Duration1, class Duration2>
> inline constexpr
> typename common_type<Duration1, Duration2>::type
> operator-(const time_point<Clock, Duration1>& lhs,
> const time_point<Clock, Duration2>& rhs)
> {
> return lhs.time_since_epoch() - rhs.time_since_epoch();
> }
>
>
>
>
>
>
>
> template <class Clock, class Duration1, class Duration2>
> inline constexpr
> bool
> operator==(const time_point<Clock, Duration1>& lhs,
> const time_point<Clock, Duration2>& rhs)
> {
> return lhs.time_since_epoch() == rhs.time_since_epoch();
> }
>
>
>
> template <class Clock, class Duration1, class Duration2>
> inline constexpr
> bool
> operator!=(const time_point<Clock, Duration1>& lhs,
> const time_point<Clock, Duration2>& rhs)
> {
> return !(lhs == rhs);
> }
>
>
>
> template <class Clock, class Duration1, class Duration2>
> inline constexpr
> bool
> operator<(const time_point<Clock, Duration1>& lhs,
> const time_point<Clock, Duration2>& rhs)
> {
> return lhs.time_since_epoch() < rhs.time_since_epoch();
> }
>
>
>
> template <class Clock, class Duration1, class Duration2>
> inline constexpr
> bool
> operator>(const time_point<Clock, Duration1>& lhs,
> const time_point<Clock, Duration2>& rhs)
> {
> return rhs < lhs;
> }
>
>
>
> template <class Clock, class Duration1, class Duration2>
> inline constexpr
> bool
> operator<=(const time_point<Clock, Duration1>& lhs,
> const time_point<Clock, Duration2>& rhs)
> {
> return !(rhs < lhs);
> }
>
>
>
> template <class Clock, class Duration1, class Duration2>
> inline constexpr
> bool
> operator>=(const time_point<Clock, Duration1>& lhs,
> const time_point<Clock, Duration2>& rhs)
> {
> return !(lhs < rhs);
> }
>
>
>
>
>
> template <class ToDuration, class Clock, class Duration>
> inline constexpr
> time_point<Clock, ToDuration>
> time_point_cast(const time_point<Clock, Duration>& t)
> {
> return time_point<Clock, ToDuration>(
> duration_cast<ToDuration>(t.time_since_epoch()));
> }
>
>}
>}
>
>
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 378 "/usr/include/boost/chrono/time_point.hpp" 2 3 4
># 23 "/usr/include/boost/thread/lock_types.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 28 "/usr/include/boost/thread/lock_types.hpp" 2 3 4
>
>namespace boost
>{
> struct xtime;
>
> template <typename Mutex>
> class shared_lock;
>
> template <typename Mutex>
> class upgrade_lock;
>
> template <typename Mutex>
> class unique_lock;
>
> namespace detail
> {
> template <typename Mutex>
> class try_lock_wrapper;
> }
># 98 "/usr/include/boost/thread/lock_types.hpp" 3 4
> template <typename Mutex>
> class unique_lock
> {
> private:
> Mutex* m;
> bool is_locked;
>
> private:
> explicit unique_lock(upgrade_lock<Mutex>&);
> unique_lock& operator=(upgrade_lock<Mutex>& other);
> public:
> typedef Mutex mutex_type;
> unique_lock(unique_lock const&) = delete; unique_lock& operator=(unique_lock const&) = delete;
>
>
>
>
>
>
> unique_lock()noexcept :
> m(0),is_locked(false)
> {}
>
> explicit unique_lock(Mutex& m_) :
> m(&m_), is_locked(false)
> {
> lock();
> }
> unique_lock(Mutex& m_, adopt_lock_t) :
> m(&m_), is_locked(true)
> {
>
>
>
> }
> unique_lock(Mutex& m_, defer_lock_t)noexcept:
> m(&m_),is_locked(false)
> {}
> unique_lock(Mutex& m_, try_to_lock_t) :
> m(&m_), is_locked(false)
> {
> try_lock();
> }
>
> template<typename TimeDuration>
> unique_lock(Mutex& m_,TimeDuration const& target_time):
> m(&m_),is_locked(false)
> {
> timed_lock(target_time);
> }
> unique_lock(Mutex& m_,system_time const& target_time):
> m(&m_),is_locked(false)
> {
> timed_lock(target_time);
> }
>
>
> template <class Clock, class Duration>
> unique_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t)
> : m(&mtx), is_locked(mtx.try_lock_until(t))
> {
> }
> template <class Rep, class Period>
> unique_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d)
> : m(&mtx), is_locked(mtx.try_lock_for(d))
> {
> }
>
>
> unique_lock(unique_lock && other) noexcept:
> m(other.m),is_locked(other.is_locked)
> {
> other.is_locked=false;
> other.m=0;
> }
>
> unique_lock( upgrade_lock<Mutex> && other);
>
>
>
> unique_lock& operator=( upgrade_lock<Mutex> && other)
> {
> unique_lock temp(::boost::move(other));
> swap(temp);
> return *this;
> }
>
>
>
> unique_lock& operator=(unique_lock && other)
> {
> unique_lock temp(::boost::move(other));
> swap(temp);
> return *this;
> }
># 204 "/usr/include/boost/thread/lock_types.hpp" 3 4
> unique_lock( upgrade_lock<mutex_type> && ul, try_to_lock_t)
> : m(0),is_locked(false)
> {
> if (ul.owns_lock())
> {
> if (ul.mutex()->try_unlock_upgrade_and_lock())
> {
> m = ul.release();
> is_locked = true;
> }
> }
> else
> {
> m = ul.release();
> }
> }
>
>
> template <class Clock, class Duration>
> unique_lock( upgrade_lock<mutex_type> && ul,
> const chrono::time_point<Clock, Duration>& abs_time)
> : m(0),is_locked(false)
> {
> if (ul.owns_lock())
> {
> if (ul.mutex()->try_unlock_upgrade_and_lock_until(abs_time))
> {
> m = ul.release();
> is_locked = true;
> }
> }
> else
> {
> m = ul.release();
> }
> }
>
> template <class Rep, class Period>
> unique_lock( upgrade_lock<mutex_type> && ul,
> const chrono::duration<Rep, Period>& rel_time)
> : m(0),is_locked(false)
> {
> if (ul.owns_lock())
> {
> if (ul.mutex()->try_unlock_upgrade_and_lock_for(rel_time))
> {
> m = ul.release();
> is_locked = true;
> }
> }
> else
> {
> m = ul.release();
> }
> }
># 321 "/usr/include/boost/thread/lock_types.hpp" 3 4
> void swap(unique_lock& other)noexcept
> {
> std::swap(m,other.m);
> std::swap(is_locked,other.is_locked);
> }
>
> ~unique_lock()
> {
> if (owns_lock())
> {
> m->unlock();
> }
> }
> void lock()
> {
> if (m == 0)
> {
> boost::throw_exception(
> boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
> }
> if (owns_lock())
> {
> boost::throw_exception(
> boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
> }
> m->lock();
> is_locked = true;
> }
> bool try_lock()
> {
> if (m == 0)
> {
> boost::throw_exception(
> boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
> }
> if (owns_lock())
> {
> boost::throw_exception(
> boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
> }
> is_locked = m->try_lock();
> return is_locked;
> }
>
> template<typename TimeDuration>
> bool timed_lock(TimeDuration const& relative_time)
> {
> if(m==0)
> {
> boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
> }
> if(owns_lock())
> {
> boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
> }
> is_locked=m->timed_lock(relative_time);
> return is_locked;
> }
>
> bool timed_lock(::boost::system_time const& absolute_time)
> {
> if(m==0)
> {
> boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
> }
> if(owns_lock())
> {
> boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
> }
> is_locked=m->timed_lock(absolute_time);
> return is_locked;
> }
> bool timed_lock(::boost::xtime const& absolute_time)
> {
> if(m==0)
> {
> boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
> }
> if(owns_lock())
> {
> boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
> }
> is_locked=m->timed_lock(absolute_time);
> return is_locked;
> }
>
>
>
> template <class Rep, class Period>
> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
> {
> if(m==0)
> {
> boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
> }
> if(owns_lock())
> {
> boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
> }
> is_locked=m->try_lock_for(rel_time);
> return is_locked;
> }
> template <class Clock, class Duration>
> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
> {
> if(m==0)
> {
> boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
> }
> if(owns_lock())
> {
> boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
> }
> is_locked=m->try_lock_until(abs_time);
> return is_locked;
> }
>
>
> void unlock()
> {
> if (m == 0)
> {
> boost::throw_exception(
> boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
> }
> if (!owns_lock())
> {
> boost::throw_exception(
> boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock doesn't own the mutex"));
> }
> m->unlock();
> is_locked = false;
> }
># 466 "/usr/include/boost/thread/lock_types.hpp" 3 4
> explicit operator bool() const noexcept
> {
> return owns_lock();
> }
>
> bool owns_lock() const noexcept
> {
> return is_locked;
> }
>
> Mutex* mutex() const noexcept
> {
> return m;
> }
>
> Mutex* release()noexcept
> {
> Mutex* const res=m;
> m=0;
> is_locked=false;
> return res;
> }
>
> friend class shared_lock<Mutex> ;
> friend class upgrade_lock<Mutex> ;
> };
>
> template<typename Mutex>
> void swap(unique_lock<Mutex>& lhs, unique_lock<Mutex>& rhs)
> noexcept
> {
> lhs.swap(rhs);
> }
>
> namespace detail { template <typename Mutex> struct enable_move_utility_emulation_dummy_specialization< unique_lock<Mutex> > : integral_constant<bool, false> {}; }
>
> template<typename Mutex>
> class shared_lock
> {
> protected:
> Mutex* m;
> bool is_locked;
>
> public:
> typedef Mutex mutex_type;
> shared_lock(shared_lock const&) = delete; shared_lock& operator=(shared_lock const&) = delete;
>
> shared_lock() noexcept:
> m(0),is_locked(false)
> {}
>
> explicit shared_lock(Mutex& m_):
> m(&m_),is_locked(false)
> {
> lock();
> }
> shared_lock(Mutex& m_,adopt_lock_t):
> m(&m_),is_locked(true)
> {
>
>
>
> }
> shared_lock(Mutex& m_,defer_lock_t) noexcept:
> m(&m_),is_locked(false)
> {}
> shared_lock(Mutex& m_,try_to_lock_t):
> m(&m_),is_locked(false)
> {
> try_lock();
> }
>
> shared_lock(Mutex& m_,system_time const& target_time):
> m(&m_),is_locked(false)
> {
> timed_lock(target_time);
> }
>
>
> template <class Clock, class Duration>
> shared_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t)
> : m(&mtx), is_locked(mtx.try_lock_shared_until(t))
> {
> }
> template <class Rep, class Period>
> shared_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d)
> : m(&mtx), is_locked(mtx.try_lock_shared_for(d))
> {
> }
>
>
> shared_lock( shared_lock<Mutex> && other) noexcept:
> m(other.m),is_locked(other.is_locked)
> {
> other.is_locked=false;
> other.m=0;
> }
>
> shared_lock( unique_lock<Mutex> && other):
> m(other.m),is_locked(other.is_locked)
> {
> if(is_locked)
> {
> m->unlock_and_lock_shared();
> }
> other.is_locked=false;
> other.m=0;
> }
>
> shared_lock( upgrade_lock<Mutex> && other):
> m(other.m),is_locked(other.is_locked)
> {
> if(is_locked)
> {
> m->unlock_upgrade_and_lock_shared();
> }
> other.is_locked=false;
> other.m=0;
> }
>
>
> shared_lock& operator=( shared_lock<Mutex> && other)
> {
> shared_lock temp(::boost::move(other));
> swap(temp);
> return *this;
> }
>
> shared_lock& operator=( unique_lock<Mutex> && other)
> {
> shared_lock temp(::boost::move(other));
> swap(temp);
> return *this;
> }
>
> shared_lock& operator=( upgrade_lock<Mutex> && other)
> {
> shared_lock temp(::boost::move(other));
> swap(temp);
> return *this;
> }
>
>
> void swap(shared_lock& other) noexcept
> {
> std::swap(m,other.m);
> std::swap(is_locked,other.is_locked);
> }
>
> Mutex* mutex() const noexcept
> {
> return m;
> }
>
> Mutex* release() noexcept
> {
> Mutex* const res=m;
> m=0;
> is_locked=false;
> return res;
> }
>
> ~shared_lock()
> {
> if(owns_lock())
> {
> m->unlock_shared();
> }
> }
> void lock()
> {
> if(m==0)
> {
> boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
> }
> if(owns_lock())
> {
> boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
> }
> m->lock_shared();
> is_locked=true;
> }
> bool try_lock()
> {
> if(m==0)
> {
> boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
> }
> if(owns_lock())
> {
> boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
> }
> is_locked=m->try_lock_shared();
> return is_locked;
> }
>
> bool timed_lock(boost::system_time const& target_time)
> {
> if(m==0)
> {
> boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
> }
> if(owns_lock())
> {
> boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
> }
> is_locked=m->timed_lock_shared(target_time);
> return is_locked;
> }
> template<typename Duration>
> bool timed_lock(Duration const& target_time)
> {
> if(m==0)
> {
> boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
> }
> if(owns_lock())
> {
> boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
> }
> is_locked=m->timed_lock_shared(target_time);
> return is_locked;
> }
>
>
> template <class Rep, class Period>
> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
> {
> if(m==0)
> {
> boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
> }
> if(owns_lock())
> {
> boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
> }
> is_locked=m->try_lock_shared_for(rel_time);
> return is_locked;
> }
> template <class Clock, class Duration>
> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
> {
> if(m==0)
> {
> boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
> }
> if(owns_lock())
> {
> boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
> }
> is_locked=m->try_lock_shared_until(abs_time);
> return is_locked;
> }
>
> void unlock()
> {
> if(m==0)
> {
> boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
> }
> if(!owns_lock())
> {
> boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock doesn't own the mutex"));
> }
> m->unlock_shared();
> is_locked=false;
> }
># 745 "/usr/include/boost/thread/lock_types.hpp" 3 4
> explicit operator bool() const noexcept
> {
> return owns_lock();
> }
>
> bool owns_lock() const noexcept
> {
> return is_locked;
> }
>
> };
>
> namespace detail { template <typename Mutex> struct enable_move_utility_emulation_dummy_specialization< shared_lock<Mutex> > : integral_constant<bool, false> {}; }
>
> template<typename Mutex>
> void swap(shared_lock<Mutex>& lhs,shared_lock<Mutex>& rhs) noexcept
> {
> lhs.swap(rhs);
> }
>
> template <typename Mutex>
> class upgrade_lock
> {
> protected:
> Mutex* m;
> bool is_locked;
>
> public:
> typedef Mutex mutex_type;
> upgrade_lock(upgrade_lock const&) = delete; upgrade_lock& operator=(upgrade_lock const&) = delete;
>
> upgrade_lock()noexcept:
> m(0),is_locked(false)
> {}
>
> explicit upgrade_lock(Mutex& m_) :
> m(&m_), is_locked(false)
> {
> lock();
> }
> upgrade_lock(Mutex& m_, adopt_lock_t) :
> m(&m_), is_locked(true)
> {
>
>
>
> }
> upgrade_lock(Mutex& m_, defer_lock_t)noexcept:
> m(&m_),is_locked(false)
> {}
> upgrade_lock(Mutex& m_, try_to_lock_t) :
> m(&m_), is_locked(false)
> {
> try_lock();
> }
>
>
> template <class Clock, class Duration>
> upgrade_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t)
> : m(&mtx), is_locked(mtx.try_lock_upgrade_until(t))
> {
> }
> template <class Rep, class Period>
> upgrade_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d)
> : m(&mtx), is_locked(mtx.try_lock_upgrade_for(d))
> {
> }
>
>
> upgrade_lock( upgrade_lock<Mutex> && other) noexcept:
> m(other.m),is_locked(other.is_locked)
> {
> other.is_locked=false;
> other.m=0;
> }
>
> upgrade_lock( unique_lock<Mutex> && other):
> m(other.m),is_locked(other.is_locked)
> {
> if(is_locked)
> {
> m->unlock_and_lock_upgrade();
> }
> other.is_locked=false;
> other.m=0;
> }
>
>
> upgrade_lock& operator=( upgrade_lock<Mutex> && other)
> {
> upgrade_lock temp(::boost::move(other));
> swap(temp);
> return *this;
> }
>
>
> upgrade_lock& operator=( unique_lock<Mutex> && other)
> {
> upgrade_lock temp(::boost::move(other));
> swap(temp);
> return *this;
> }
># 908 "/usr/include/boost/thread/lock_types.hpp" 3 4
> void swap(upgrade_lock& other)noexcept
> {
> std::swap(m,other.m);
> std::swap(is_locked,other.is_locked);
> }
> Mutex* mutex() const noexcept
> {
> return m;
> }
>
> Mutex* release()noexcept
> {
> Mutex* const res=m;
> m=0;
> is_locked=false;
> return res;
> }
> ~upgrade_lock()
> {
> if (owns_lock())
> {
> m->unlock_upgrade();
> }
> }
> void lock()
> {
> if (m == 0)
> {
> boost::throw_exception(
> boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
> }
> if (owns_lock())
> {
> boost::throw_exception(
> boost::lock_error(system::errc::resource_deadlock_would_occur, "boost upgrade_lock owns already the mutex"));
> }
> m->lock_upgrade();
> is_locked = true;
> }
> bool try_lock()
> {
> if (m == 0)
> {
> boost::throw_exception(
> boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
> }
> if (owns_lock())
> {
> boost::throw_exception(
> boost::lock_error(system::errc::resource_deadlock_would_occur, "boost upgrade_lock owns already the mutex"));
> }
> is_locked = m->try_lock_upgrade();
> return is_locked;
> }
> void unlock()
> {
> if (m == 0)
> {
> boost::throw_exception(
> boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
> }
> if (!owns_lock())
> {
> boost::throw_exception(
> boost::lock_error(system::errc::operation_not_permitted, "boost upgrade_lock doesn't own the mutex"));
> }
> m->unlock_upgrade();
> is_locked = false;
> }
>
> template <class Rep, class Period>
> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
> {
> if(m==0)
> {
> boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
> }
> if(owns_lock())
> {
> boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
> }
> is_locked=m->try_lock_upgrade_for(rel_time);
> return is_locked;
> }
> template <class Clock, class Duration>
> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
> {
> if(m==0)
> {
> boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
> }
> if(owns_lock())
> {
> boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
> }
> is_locked=m->try_lock_upgrade_until(abs_time);
> return is_locked;
> }
># 1018 "/usr/include/boost/thread/lock_types.hpp" 3 4
> explicit operator bool() const noexcept
> {
> return owns_lock();
> }
>
> bool owns_lock() const noexcept
> {
> return is_locked;
> }
> friend class shared_lock<Mutex> ;
> friend class unique_lock<Mutex> ;
> };
>
> template<typename Mutex>
> void swap(upgrade_lock<Mutex>& lhs, upgrade_lock<Mutex>& rhs)
> noexcept
> {
> lhs.swap(rhs);
> }
>
> namespace detail { template <typename Mutex> struct enable_move_utility_emulation_dummy_specialization< upgrade_lock<Mutex> > : integral_constant<bool, false> {}; }
>
> template<typename Mutex>
> unique_lock<Mutex>::unique_lock( upgrade_lock<Mutex> && other):
> m(other.m),is_locked(other.is_locked)
> {
> if(is_locked)
> {
> m->unlock_upgrade_and_lock();
> }
> other.release();
> }
>
> template <class Mutex>
> class upgrade_to_unique_lock
> {
> private:
> upgrade_lock<Mutex>* source;
> unique_lock<Mutex> exclusive;
>
> public:
> typedef Mutex mutex_type;
> upgrade_to_unique_lock(upgrade_to_unique_lock const&) = delete; upgrade_to_unique_lock& operator=(upgrade_to_unique_lock const&) = delete;
>
> explicit upgrade_to_unique_lock(upgrade_lock<Mutex>& m_) :
> source(&m_), exclusive(::boost::move(*source))
> {
> }
> ~upgrade_to_unique_lock()
> {
> if (source)
> {
> *source = upgrade_lock<Mutex> (::boost::move(exclusive));
> }
> }
>
> upgrade_to_unique_lock( upgrade_to_unique_lock<Mutex> && other) noexcept:
> source(other.source),exclusive(::boost::move(other.exclusive))
> {
> other.source=0;
> }
>
>
> upgrade_to_unique_lock& operator=( upgrade_to_unique_lock<Mutex> && other)
> {
> upgrade_to_unique_lock temp(other);
> swap(temp);
> return *this;
> }
>
> void swap(upgrade_to_unique_lock& other)noexcept
> {
> std::swap(source,other.source);
> exclusive.swap(other.exclusive);
> }
># 1105 "/usr/include/boost/thread/lock_types.hpp" 3 4
> explicit operator bool() const noexcept
> {
> return owns_lock();
> }
>
>
> bool owns_lock() const noexcept
> {
> return exclusive.owns_lock();
> }
> };
>
>namespace detail { template <typename Mutex> struct enable_move_utility_emulation_dummy_specialization< upgrade_to_unique_lock<Mutex> > : integral_constant<bool, false> {}; }
>
>namespace detail
>{
> template<typename Mutex>
> class try_lock_wrapper:
>private unique_lock<Mutex>
> {
> typedef unique_lock<Mutex> base;
> public:
> try_lock_wrapper(try_lock_wrapper const&) = delete; try_lock_wrapper& operator=(try_lock_wrapper const&) = delete;
>
> try_lock_wrapper()
> {}
>
> explicit try_lock_wrapper(Mutex& m):
> base(m,try_to_lock)
> {}
>
> try_lock_wrapper(Mutex& m_,adopt_lock_t):
> base(m_,adopt_lock)
> {
>
>
>
> }
> try_lock_wrapper(Mutex& m_,defer_lock_t):
> base(m_,defer_lock)
> {}
> try_lock_wrapper(Mutex& m_,try_to_lock_t):
> base(m_,try_to_lock)
> {}
>
> try_lock_wrapper(try_lock_wrapper && other):
> base(::boost::move(other))
> {}
># 1164 "/usr/include/boost/thread/lock_types.hpp" 3 4
> try_lock_wrapper& operator=( try_lock_wrapper<Mutex> && other)
> {
> try_lock_wrapper temp(other);
> swap(temp);
> return *this;
> }
> void swap(try_lock_wrapper& other)
> {
> base::swap(other);
> }
> void lock()
> {
> base::lock();
> }
> bool try_lock()
> {
> return base::try_lock();
> }
> void unlock()
> {
> base::unlock();
> }
> bool owns_lock() const
> {
> return base::owns_lock();
> }
> Mutex* mutex() const
> {
> return base::mutex();
> }
> Mutex* release()
> {
> return base::release();
> }
># 1210 "/usr/include/boost/thread/lock_types.hpp" 3 4
> explicit operator bool() const
> {
> return owns_lock();
> }
>
> };
>
> template<typename Mutex>
> void swap(try_lock_wrapper<Mutex>& lhs,try_lock_wrapper<Mutex>& rhs)
> {
> lhs.swap(rhs);
> }
>}
>}
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 1225 "/usr/include/boost/thread/lock_types.hpp" 2 3 4
># 13 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
># 1 "/usr/include/boost/thread/mutex.hpp" 1 3 4
># 16 "/usr/include/boost/thread/mutex.hpp" 3 4
># 1 "/usr/include/boost/thread/pthread/mutex.hpp" 1 3 4
># 17 "/usr/include/boost/thread/pthread/mutex.hpp" 3 4
># 1 "/usr/include/boost/thread/xtime.hpp" 1 3 4
># 14 "/usr/include/boost/thread/xtime.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 15 "/usr/include/boost/thread/xtime.hpp" 2 3 4
>
># 1 "/usr/include/boost/date_time/posix_time/conversion.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/posix_time/conversion.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 13 "/usr/include/boost/date_time/posix_time/conversion.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/date_time/gregorian/conversion.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/gregorian/conversion.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 13 "/usr/include/boost/date_time/gregorian/conversion.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost {
>
>namespace gregorian {
>
>
> inline
> std::tm to_tm(const date& d)
> {
> if (d.is_special())
> {
> std::string s = "tm unable to handle ";
> switch (d.as_special())
> {
> case date_time::not_a_date_time:
> s += "not-a-date-time value"; break;
> case date_time::neg_infin:
> s += "-infinity date value"; break;
> case date_time::pos_infin:
> s += "+infinity date value"; break;
> default:
> s += "a special date value"; break;
> }
> boost::throw_exception(std::out_of_range(s));
> }
>
> std::tm datetm;
> std::memset(&datetm, 0, sizeof(datetm));
> boost::gregorian::date::ymd_type ymd = d.year_month_day();
> datetm.tm_year = ymd.year - 1900;
> datetm.tm_mon = ymd.month - 1;
> datetm.tm_mday = ymd.day;
> datetm.tm_wday = d.day_of_week();
> datetm.tm_yday = d.day_of_year() - 1;
> datetm.tm_isdst = -1;
> return datetm;
> }
>
>
> inline
> date date_from_tm(const std::tm& datetm)
> {
> return date(static_cast<unsigned short>(datetm.tm_year+1900),
> static_cast<unsigned short>(datetm.tm_mon+1),
> static_cast<unsigned short>(datetm.tm_mday));
> }
>
>} }
># 19 "/usr/include/boost/date_time/posix_time/conversion.hpp" 2 3 4
>
>namespace boost {
>
>namespace posix_time {
>
>
>
> inline
> ptime from_time_t(std::time_t t)
> {
> ptime start(gregorian::date(1970,1,1));
> return start + seconds(static_cast<long>(t));
> }
>
>
> inline
> std::tm to_tm(const boost::posix_time::ptime& t) {
> std::tm timetm = boost::gregorian::to_tm(t.date());
> boost::posix_time::time_duration td = t.time_of_day();
> timetm.tm_hour = td.hours();
> timetm.tm_min = td.minutes();
> timetm.tm_sec = td.seconds();
> timetm.tm_isdst = -1;
> return timetm;
> }
>
> inline
> std::tm to_tm(const boost::posix_time::time_duration& td) {
> std::tm timetm;
> std::memset(&timetm, 0, sizeof(timetm));
> timetm.tm_hour = date_time::absolute_value(td.hours());
> timetm.tm_min = date_time::absolute_value(td.minutes());
> timetm.tm_sec = date_time::absolute_value(td.seconds());
> timetm.tm_isdst = -1;
> return timetm;
> }
>
>
> inline
> ptime ptime_from_tm(const std::tm& timetm) {
> boost::gregorian::date d = boost::gregorian::date_from_tm(timetm);
> return ptime(d, time_duration(timetm.tm_hour, timetm.tm_min, timetm.tm_sec));
> }
># 88 "/usr/include/boost/date_time/posix_time/conversion.hpp" 3 4
>} }
># 17 "/usr/include/boost/thread/xtime.hpp" 2 3 4
>
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 19 "/usr/include/boost/thread/xtime.hpp" 2 3 4
>
>namespace boost {
>
>enum xtime_clock_types
>{
> TIME_UTC_=1
>
>
>
>
>
>
>
>};
>
>struct xtime
>{
>
>
>
> typedef int_fast64_t xtime_sec_t;
>
>
> typedef int_fast32_t xtime_nsec_t;
>
> xtime_sec_t sec;
> xtime_nsec_t nsec;
>
> operator system_time() const
> {
> return boost::posix_time::from_time_t(0)+
> boost::posix_time::seconds(static_cast<long>(sec))+
>
>
>
> boost::posix_time::microseconds((nsec+500)/1000);
>
> }
>
>};
>
>inline xtime get_xtime(boost::system_time const& abs_time)
>{
> xtime res;
> boost::posix_time::time_duration const time_since_epoch=abs_time-boost::posix_time::from_time_t(0);
>
> res.sec=static_cast<xtime::xtime_sec_t>(time_since_epoch.total_seconds());
> res.nsec=static_cast<xtime::xtime_nsec_t>(time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second()));
> return res;
>}
>
>inline int xtime_get(struct xtime* xtp, int clock_type)
>{
> if (clock_type == TIME_UTC_)
> {
> *xtp=get_xtime(get_system_time());
> return clock_type;
> }
> return 0;
>}
>
>
>inline int xtime_cmp(const xtime& xt1, const xtime& xt2)
>{
> if (xt1.sec == xt2.sec)
> return (int)(xt1.nsec - xt2.nsec);
> else
> return (xt1.sec > xt2.sec) ? 1 : -1;
>}
>
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 92 "/usr/include/boost/thread/xtime.hpp" 2 3 4
># 18 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 19 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
># 1 "/usr/include/errno.h" 1 3 4
># 20 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
># 1 "/usr/include/boost/thread/pthread/timespec.hpp" 1 3 4
># 30 "/usr/include/boost/thread/pthread/timespec.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 31 "/usr/include/boost/thread/pthread/timespec.hpp" 2 3 4
>
>namespace boost
>{
> namespace detail
> {
>
> inline struct timespec to_timespec(boost::system_time const& abs_time)
> {
> struct timespec timeout = { 0,0};
> boost::posix_time::time_duration const time_since_epoch=abs_time-boost::posix_time::from_time_t(0);
>
> timeout.tv_sec=time_since_epoch.total_seconds();
> timeout.tv_nsec=(long)(time_since_epoch.fractional_seconds()*(1000000000l/time_since_epoch.ticks_per_second()));
> return timeout;
> }
>
>
> inline timespec to_timespec(chrono::nanoseconds const& ns)
> {
> struct timespec ts;
> ts.tv_sec = static_cast<long>(chrono::duration_cast<chrono::seconds>(ns).count());
> ts.tv_nsec = static_cast<long>((ns - chrono::duration_cast<chrono::seconds>(ns)).count());
> return ts;
> }
>
>
>
> inline timespec to_timespec(boost::intmax_t const& ns)
> {
> boost::intmax_t s = ns / 1000000000l;
> struct timespec ts;
> ts.tv_sec = static_cast<long> (s);
> ts.tv_nsec = static_cast<long> (ns - s * 1000000000l);
> return ts;
> }
> inline boost::intmax_t to_nanoseconds_int_max(timespec const& ts)
> {
> return static_cast<boost::intmax_t>(ts.tv_sec) * 1000000000l + ts.tv_nsec;
> }
> inline bool timespec_ge_zero(timespec const& ts)
> {
> return (ts.tv_sec >= 0) || (ts.tv_nsec >= 0);
> }
> inline timespec timespec_now()
> {
> timespec ts;
>
>
>
>
>
>
>
> if ( ::clock_gettime( 0, &ts ) )
> {
> ((void)0);
> }
>
> return ts;
> }
> inline timespec timespec_zero()
> {
> timespec ts;
> ts.tv_sec = 0;
> ts.tv_nsec = 0;
> return ts;
> }
> inline timespec timespec_plus(timespec const& lhs, timespec const& rhs)
> {
> return to_timespec(to_nanoseconds_int_max(lhs) + to_nanoseconds_int_max(rhs));
> }
> inline timespec timespec_minus(timespec const& lhs, timespec const& rhs)
> {
> return to_timespec(to_nanoseconds_int_max(lhs) - to_nanoseconds_int_max(rhs));
> }
> inline bool timespec_gt(timespec const& lhs, timespec const& rhs)
> {
> return to_nanoseconds_int_max(lhs) > to_nanoseconds_int_max(rhs);
> }
> inline bool timespec_ge(timespec const& lhs, timespec const& rhs)
> {
> return to_nanoseconds_int_max(lhs) >= to_nanoseconds_int_max(rhs);
> }
>
> }
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 119 "/usr/include/boost/thread/pthread/timespec.hpp" 2 3 4
># 21 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
># 1 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 1 3 4
># 10 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 11 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 2 3 4
>
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 13 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 2 3 4
>
>namespace boost
>{
> namespace pthread
> {
> class pthread_mutex_scoped_lock
> {
> pthread_mutex_t* m;
> bool locked;
> public:
> explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_):
> m(m_),locked(true)
> {
> ((void)(!pthread_mutex_lock(m)));
> }
> void unlock()
> {
> ((void)(!pthread_mutex_unlock(m)));
> locked=false;
> }
>
> ~pthread_mutex_scoped_lock()
> {
> if(locked)
> {
> unlock();
> }
> }
>
> };
>
> class pthread_mutex_scoped_unlock
> {
> pthread_mutex_t* m;
> public:
> explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_):
> m(m_)
> {
> ((void)(!pthread_mutex_unlock(m)));
> }
> ~pthread_mutex_scoped_unlock()
> {
> ((void)(!pthread_mutex_lock(m)));
> }
>
> };
> }
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 63 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 2 3 4
># 22 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
>
># 1 "/usr/include/boost/chrono/system_clocks.hpp" 1 3 4
># 64 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
># 1 "/usr/include/boost/chrono/detail/system.hpp" 1 3 4
># 65 "/usr/include/boost/chrono/system_clocks.hpp" 2 3 4
># 1 "/usr/include/boost/chrono/clock_string.hpp" 1 3 4
># 13 "/usr/include/boost/chrono/clock_string.hpp" 3 4
>namespace boost
>{
> namespace chrono
> {
>
> template<class Clock, class CharT>
> struct clock_string;
>
> }
>
>}
># 66 "/usr/include/boost/chrono/system_clocks.hpp" 2 3 4
>
># 1 "/usr/include/c++/4.8.2/ctime" 1 3 4
># 39 "/usr/include/c++/4.8.2/ctime" 3 4
> 
># 40 "/usr/include/c++/4.8.2/ctime" 3
># 68 "/usr/include/boost/chrono/system_clocks.hpp" 2 3 4
># 84 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 85 "/usr/include/boost/chrono/system_clocks.hpp" 2 3 4
># 95 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
>namespace boost {
>namespace chrono {
>
>
> class system_clock;
>
> class steady_clock;
>
>
>
> typedef steady_clock high_resolution_clock;
># 127 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
> class system_clock
> {
> public:
> typedef boost::chrono::nanoseconds duration;
> typedef duration::rep rep;
> typedef duration::period period;
> typedef chrono::time_point<system_clock> time_point;
> static constexpr bool is_steady = false;
>
> static time_point now() noexcept;
>
> static time_point now(system::error_code & ec);
>
>
> static std::time_t to_time_t(const time_point& t) noexcept;
> static time_point from_time_t(std::time_t t) noexcept;
> };
># 153 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
> class steady_clock
> {
> public:
> typedef nanoseconds duration;
> typedef duration::rep rep;
> typedef duration::period period;
> typedef chrono::time_point<steady_clock> time_point;
> static constexpr bool is_steady = true;
>
> static time_point now() noexcept;
>
> static time_point now(system::error_code & ec);
>
> };
># 176 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
> template<class CharT>
> struct clock_string<system_clock, CharT>
> {
> static std::basic_string<CharT> name()
> {
> static const CharT u[] =
> { 's', 'y', 's', 't', 'e', 'm', '_', 'c', 'l', 'o', 'c', 'k' };
> static const std::basic_string<CharT> str(u, u + sizeof(u)
> / sizeof(u[0]));
> return str;
> }
> static std::basic_string<CharT> since()
> {
> static const CharT
> u[] =
> { ' ', 's', 'i', 'n', 'c', 'e', ' ', 'J', 'a', 'n', ' ', '1', ',', ' ', '1', '9', '7', '0' };
> static const std::basic_string<CharT> str(u, u + sizeof(u)
> / sizeof(u[0]));
> return str;
> }
> };
>
>
>
> template<class CharT>
> struct clock_string<steady_clock, CharT>
> {
> static std::basic_string<CharT> name()
> {
> static const CharT
> u[] =
> { 's', 't', 'e', 'a', 'd', 'y', '_', 'c', 'l', 'o', 'c', 'k' };
> static const std::basic_string<CharT> str(u, u + sizeof(u)
> / sizeof(u[0]));
> return str;
> }
> static std::basic_string<CharT> since()
> {
> const CharT u[] =
> { ' ', 's', 'i', 'n', 'c', 'e', ' ', 'b', 'o', 'o', 't' };
> const std::basic_string<CharT> str(u, u + sizeof(u) / sizeof(u[0]));
> return str;
> }
> };
>
>
>
>}
>}
>
>
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 229 "/usr/include/boost/chrono/system_clocks.hpp" 2 3 4
># 24 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
># 1 "/usr/include/boost/chrono/ceil.hpp" 1 3 4
># 16 "/usr/include/boost/chrono/ceil.hpp" 3 4
>namespace boost
>{
> namespace chrono
> {
>
>
>
>
> template <class To, class Rep, class Period>
> To ceil(const duration<Rep, Period>& d)
> {
> To t = duration_cast<To>(d);
> if (t < d)
> ++t;
> return t;
> }
>
> }
>}
># 25 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
># 37 "/usr/include/boost/thread/pthread/mutex.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 38 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
>
>
>
>
>
>namespace boost
>{
> namespace posix {
>
> inline __attribute__ ((__always_inline__)) int pthread_mutex_destroy(pthread_mutex_t* m)
> {
> int ret;
> do
> {
> ret = ::pthread_mutex_destroy(m);
> } while (ret == 4);
> return ret;
> }
> inline __attribute__ ((__always_inline__)) int pthread_mutex_lock(pthread_mutex_t* m)
> {
> int ret;
> do
> {
> ret = ::pthread_mutex_lock(m);
> } while (ret == 4);
> return ret;
> }
> inline __attribute__ ((__always_inline__)) int pthread_mutex_unlock(pthread_mutex_t* m)
> {
> int ret;
> do
> {
> ret = ::pthread_mutex_unlock(m);
> } while (ret == 4);
> return ret;
> }
># 90 "/usr/include/boost/thread/pthread/mutex.hpp" 3 4
> }
> class mutex
> {
> private:
> pthread_mutex_t m;
> public:
> mutex(mutex const&) = delete; mutex& operator=(mutex const&) = delete;
>
> mutex()
> {
> int const res=pthread_mutex_init(&m,__null);
> if(res)
> {
> boost::throw_exception(thread_resource_error(res, "boost:: mutex constructor failed in pthread_mutex_init"));
> }
> }
> ~mutex()
> {
> ((void)(!posix::pthread_mutex_destroy(&m)));
> }
>
> void lock()
> {
> int res = posix::pthread_mutex_lock(&m);
> if (res)
> {
> boost::throw_exception(lock_error(res,"boost: mutex lock failed in pthread_mutex_lock"));
> }
> }
>
> void unlock()
> {
> int res = posix::pthread_mutex_unlock(&m);
> if (res)
> {
> boost::throw_exception(lock_error(res,"boost: mutex unlock failed in pthread_mutex_unlock"));
> }
> }
>
> bool try_lock()
> {
> int res;
> do
> {
> res = pthread_mutex_trylock(&m);
> } while (res == 4);
> if (res==16)
> {
> return false;
> }
>
> return !res;
> }
>
>
> typedef pthread_mutex_t* native_handle_type;
> native_handle_type native_handle()
> {
> return &m;
> }
>
>
> typedef unique_lock<mutex> scoped_lock;
> typedef detail::try_lock_wrapper<mutex> scoped_try_lock;
>
> };
>
> typedef mutex try_mutex;
>
> class timed_mutex
> {
> private:
> pthread_mutex_t m;
>
>
>
>
> public:
> timed_mutex(timed_mutex const&) = delete; timed_mutex& operator=(timed_mutex const&) = delete;
> timed_mutex()
> {
> int const res=pthread_mutex_init(&m,__null);
> if(res)
> {
> boost::throw_exception(thread_resource_error(res, "boost:: timed_mutex constructor failed in pthread_mutex_init"));
> }
># 186 "/usr/include/boost/thread/pthread/mutex.hpp" 3 4
> }
> ~timed_mutex()
> {
> ((void)(!posix::pthread_mutex_destroy(&m)));
>
>
>
> }
>
>
> template<typename TimeDuration>
> bool timed_lock(TimeDuration const & relative_time)
> {
> return timed_lock(get_system_time()+relative_time);
> }
> bool timed_lock(boost::xtime const & absolute_time)
> {
> return timed_lock(system_time(absolute_time));
> }
>
>
> void lock()
> {
> int res = posix::pthread_mutex_lock(&m);
> if (res)
> {
> boost::throw_exception(lock_error(res,"boost: mutex lock failed in pthread_mutex_lock"));
> }
> }
>
> void unlock()
> {
> int res = posix::pthread_mutex_unlock(&m);
> if (res)
> {
> boost::throw_exception(lock_error(res,"boost: mutex unlock failed in pthread_mutex_unlock"));
> }
> }
>
> bool try_lock()
> {
> int res;
> do
> {
> res = pthread_mutex_trylock(&m);
> } while (res == 4);
> if (res==16)
> {
> return false;
> }
>
> return !res;
> }
>
>
> private:
> bool do_try_lock_until(struct timespec const &timeout)
> {
> int const res=pthread_mutex_timedlock(&m,&timeout);
> ((void)0);
> return !res;
> }
> public:
># 299 "/usr/include/boost/thread/pthread/mutex.hpp" 3 4
> bool timed_lock(system_time const & abs_time)
> {
> struct timespec const ts=boost::detail::to_timespec(abs_time);
> return do_try_lock_until(ts);
> }
>
>
> template <class Rep, class Period>
> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
> {
> return try_lock_until(chrono::steady_clock::now() + rel_time);
> }
> template <class Clock, class Duration>
> bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
> {
> using namespace chrono;
> system_clock::time_point s_now = system_clock::now();
> typename Clock::time_point c_now = Clock::now();
> return try_lock_until(s_now + ceil<nanoseconds>(t - c_now));
> }
> template <class Duration>
> bool try_lock_until(const chrono::time_point<chrono::system_clock, Duration>& t)
> {
> using namespace chrono;
> typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
> return try_lock_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
> }
> bool try_lock_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
> {
>
> chrono::nanoseconds d = tp.time_since_epoch();
> timespec ts = boost::detail::to_timespec(d);
> return do_try_lock_until(ts);
> }
>
>
>
> typedef pthread_mutex_t* native_handle_type;
> native_handle_type native_handle()
> {
> return &m;
> }
>
>
> typedef unique_lock<timed_mutex> scoped_timed_lock;
> typedef detail::try_lock_wrapper<timed_mutex> scoped_try_lock;
> typedef scoped_timed_lock scoped_lock;
>
> };
>
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 352 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
># 17 "/usr/include/boost/thread/mutex.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost
>{
> namespace sync
> {
># 50 "/usr/include/boost/thread/mutex.hpp" 3 4
> }
>}
># 14 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
># 1 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 1 3 4
># 9 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 10 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/thread/cv_status.hpp" 1 3 4
># 14 "/usr/include/boost/thread/cv_status.hpp" 3 4
>namespace boost
>{
>
>
> enum class cv_status
> {
> no_timeout,
> timeout
> }
> ;
>}
># 13 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 2 3 4
># 27 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 28 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 2 3 4
>
>namespace boost
>{
>
> class condition_variable
> {
> private:
>
> pthread_mutex_t internal_mutex;
>
> pthread_cond_t cond;
>
> public:
>
>
> inline bool do_wait_until(
> unique_lock<mutex>& lock,
> struct timespec const &timeout);
>
> bool do_wait_for(
> unique_lock<mutex>& lock,
> struct timespec const &timeout)
> {
> return do_wait_until(lock, boost::detail::timespec_plus(timeout, boost::detail::timespec_now()));
> }
>
> public:
> condition_variable(condition_variable const&) = delete; condition_variable& operator=(condition_variable const&) = delete;
> condition_variable()
> {
>
> int const res=pthread_mutex_init(&internal_mutex,__null);
> if(res)
> {
> boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in pthread_mutex_init"));
> }
>
> int const res2=pthread_cond_init(&cond,__null);
> if(res2)
> {
>
> ((void)(!pthread_mutex_destroy(&internal_mutex)));
>
> boost::throw_exception(thread_resource_error(res2, "boost::condition_variable::condition_variable() constructor failed in pthread_cond_init"));
> }
> }
> ~condition_variable()
> {
> int ret;
>
> do {
> ret = pthread_mutex_destroy(&internal_mutex);
> } while (ret == 4);
> ((void)0);
>
> do {
> ret = pthread_cond_destroy(&cond);
> } while (ret == 4);
> ((void)0);
> }
>
> void wait(unique_lock<mutex>& m);
>
> template<typename predicate_type>
> void wait(unique_lock<mutex>& m,predicate_type pred)
> {
> while(!pred()) wait(m);
> }
>
>
>
> inline bool timed_wait(
> unique_lock<mutex>& m,
> boost::system_time const& a_wait_until)
> {
>
>
>
>
> struct timespec const timeout=detail::to_timespec(a_wait_until);
> return do_wait_until(m, timeout);
>
> }
> bool timed_wait(
> unique_lock<mutex>& m,
> xtime const& a_wait_until)
> {
> return timed_wait(m,system_time(a_wait_until));
> }
>
> template<typename duration_type>
> bool timed_wait(
> unique_lock<mutex>& m,
> duration_type const& wait_duration)
> {
> return timed_wait(m,get_system_time()+wait_duration);
> }
>
> template<typename predicate_type>
> bool timed_wait(
> unique_lock<mutex>& m,
> boost::system_time const& a_wait_until,predicate_type pred)
> {
> while (!pred())
> {
> if(!timed_wait(m, a_wait_until))
> return pred();
> }
> return true;
> }
>
> template<typename predicate_type>
> bool timed_wait(
> unique_lock<mutex>& m,
> xtime const& a_wait_until,predicate_type pred)
> {
> return timed_wait(m,system_time(a_wait_until),pred);
> }
>
> template<typename duration_type,typename predicate_type>
> bool timed_wait(
> unique_lock<mutex>& m,
> duration_type const& wait_duration,predicate_type pred)
> {
> return timed_wait(m,get_system_time()+wait_duration,pred);
> }
>
>
>
>
> template <class Duration>
> cv_status
> wait_until(
> unique_lock<mutex>& lock,
> const chrono::time_point<chrono::system_clock, Duration>& t)
> {
> using namespace chrono;
> typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
> wait_until(lock,
> nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
> return system_clock::now() < t ? cv_status::no_timeout :
> cv_status::timeout;
> }
>
> template <class Clock, class Duration>
> cv_status
> wait_until(
> unique_lock<mutex>& lock,
> const chrono::time_point<Clock, Duration>& t)
> {
> using namespace chrono;
> system_clock::time_point s_now = system_clock::now();
> typename Clock::time_point c_now = Clock::now();
> wait_until(lock, s_now + ceil<nanoseconds>(t - c_now));
> return Clock::now() < t ? cv_status::no_timeout : cv_status::timeout;
> }
>
> template <class Clock, class Duration, class Predicate>
> bool
> wait_until(
> unique_lock<mutex>& lock,
> const chrono::time_point<Clock, Duration>& t,
> Predicate pred)
> {
> while (!pred())
> {
> if (wait_until(lock, t) == cv_status::timeout)
> return pred();
> }
> return true;
> }
>
>
> template <class Rep, class Period>
> cv_status
> wait_for(
> unique_lock<mutex>& lock,
> const chrono::duration<Rep, Period>& d)
> {
> using namespace chrono;
> system_clock::time_point s_now = system_clock::now();
> steady_clock::time_point c_now = steady_clock::now();
> wait_until(lock, s_now + ceil<nanoseconds>(d));
> return steady_clock::now() - c_now < d ? cv_status::no_timeout :
> cv_status::timeout;
>
> }
>
>
> template <class Rep, class Period, class Predicate>
> bool
> wait_for(
> unique_lock<mutex>& lock,
> const chrono::duration<Rep, Period>& d,
> Predicate pred)
> {
> return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));
>
>
>
>
>
>
>
> }
>
>
>
> typedef pthread_cond_t* native_handle_type;
> native_handle_type native_handle()
> {
> return &cond;
> }
>
> void notify_one() noexcept;
> void notify_all() noexcept;
>
>
> inline cv_status wait_until(
> unique_lock<mutex>& lk,
> chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp)
> {
> using namespace chrono;
> nanoseconds d = tp.time_since_epoch();
> timespec ts = boost::detail::to_timespec(d);
> if (do_wait_until(lk, ts)) return cv_status::no_timeout;
> else return cv_status::timeout;
> }
>
> };
>
> __attribute__((__visibility__("default"))) void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
>
>}
>
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 265 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 2 3 4
># 15 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/enable_shared_from_this.hpp" 1 3 4
># 16 "/usr/include/boost/enable_shared_from_this.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/enable_shared_from_this.hpp" 1 3 4
># 16 "/usr/include/boost/smart_ptr/enable_shared_from_this.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/weak_ptr.hpp" 1 3 4
># 20 "/usr/include/boost/smart_ptr/weak_ptr.hpp" 3 4
>namespace boost
>{
>
>template<class T> class weak_ptr
>{
>private:
>
>
> typedef weak_ptr<T> this_type;
>
>public:
>
> typedef typename boost::detail::sp_element< T >::type element_type;
>
> weak_ptr() noexcept : px(0), pn()
> {
> }
>
>
>
>
>
>
>
> weak_ptr( weak_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
> {
> }
>
> weak_ptr & operator=( weak_ptr const & r ) noexcept
> {
> px = r.px;
> pn = r.pn;
> return *this;
> }
># 74 "/usr/include/boost/smart_ptr/weak_ptr.hpp" 3 4
> template<class Y>
>
>
> weak_ptr( weak_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
>
>
>
>
>
>
> noexcept : px(r.lock().get()), pn(r.pn)
> {
> boost::detail::sp_assert_convertible< Y, T >();
> }
>
>
>
> template<class Y>
>
>
> weak_ptr( weak_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
>
>
>
>
>
>
> noexcept : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
> {
> boost::detail::sp_assert_convertible< Y, T >();
> r.px = 0;
> }
>
>
> weak_ptr( weak_ptr && r )
> noexcept : px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
> {
> r.px = 0;
> }
>
>
> weak_ptr & operator=( weak_ptr && r ) noexcept
> {
> this_type( static_cast< weak_ptr && >( r ) ).swap( *this );
> return *this;
> }
>
>
>
>
> template<class Y>
>
>
> weak_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
>
>
>
>
>
>
> noexcept : px( r.px ), pn( r.pn )
> {
> boost::detail::sp_assert_convertible< Y, T >();
> }
>
>
>
> template<class Y>
> weak_ptr & operator=( weak_ptr<Y> const & r ) noexcept
> {
> boost::detail::sp_assert_convertible< Y, T >();
>
> px = r.lock().get();
> pn = r.pn;
>
> return *this;
> }
>
>
>
> template<class Y>
> weak_ptr & operator=( weak_ptr<Y> && r ) noexcept
> {
> this_type( static_cast< weak_ptr<Y> && >( r ) ).swap( *this );
> return *this;
> }
>
>
>
> template<class Y>
> weak_ptr & operator=( shared_ptr<Y> const & r ) noexcept
> {
> boost::detail::sp_assert_convertible< Y, T >();
>
> px = r.px;
> pn = r.pn;
>
> return *this;
> }
>
>
>
> shared_ptr<T> lock() const noexcept
> {
> return shared_ptr<T>( *this, boost::detail::sp_nothrow_tag() );
> }
>
> long use_count() const noexcept
> {
> return pn.use_count();
> }
>
> bool expired() const noexcept
> {
> return pn.use_count() == 0;
> }
>
> bool _empty() const
> {
> return pn.empty();
> }
>
> void reset() noexcept
> {
> this_type().swap(*this);
> }
>
> void swap(this_type & other) noexcept
> {
> std::swap(px, other.px);
> pn.swap(other.pn);
> }
>
> template<typename Y>
> void _internal_aliasing_assign(weak_ptr<Y> const & r, element_type * px2)
> {
> px = px2;
> pn = r.pn;
> }
>
> template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const noexcept
> {
> return pn < rhs.pn;
> }
>
> template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const noexcept
> {
> return pn < rhs.pn;
> }
>
>
>
>
>
>
>private:
>
> template<class Y> friend class weak_ptr;
> template<class Y> friend class shared_ptr;
>
>
>
> element_type * px;
> boost::detail::weak_count pn;
>
>};
>
>template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr const & b) noexcept
>{
> return a.owner_before( b );
>}
>
>template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) noexcept
>{
> a.swap(b);
>}
>
>}
># 17 "/usr/include/boost/smart_ptr/enable_shared_from_this.hpp" 2 3 4
>
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 19 "/usr/include/boost/smart_ptr/enable_shared_from_this.hpp" 2 3 4
>
>
>namespace boost
>{
>
>template<class T> class enable_shared_from_this
>{
>protected:
>
> enable_shared_from_this() noexcept
> {
> }
>
> enable_shared_from_this(enable_shared_from_this const &) noexcept
> {
> }
>
> enable_shared_from_this & operator=(enable_shared_from_this const &) noexcept
> {
> return *this;
> }
>
> ~enable_shared_from_this() noexcept
> {
> }
>
>public:
>
> shared_ptr<T> shared_from_this()
> {
> shared_ptr<T> p( weak_this_ );
> ((void)0);
> return p;
> }
>
> shared_ptr<T const> shared_from_this() const
> {
> shared_ptr<T const> p( weak_this_ );
> ((void)0);
> return p;
> }
>
>public:
>
>
> template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const
> {
> if( weak_this_.expired() )
> {
> weak_this_ = shared_ptr<T>( *ppx, py );
> }
> }
>
>private:
>
> mutable weak_ptr<T> weak_this_;
>};
>
>}
># 17 "/usr/include/boost/enable_shared_from_this.hpp" 2 3 4
># 18 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
>
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 20 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
># 35 "/usr/include/boost/thread/pthread/thread_data.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 36 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
>
>namespace boost
>{
> class thread_attributes {
> public:
> thread_attributes() noexcept {
> int res = pthread_attr_init(&val_);
> ((void)(!res && "pthread_attr_init failed"));
> }
> ~thread_attributes() {
> int res = pthread_attr_destroy(&val_);
> ((void)(!res && "pthread_attr_destroy failed"));
> }
>
> void set_stack_size(std::size_t size) noexcept {
> if (size==0) return;
> std::size_t page_size = getpagesize();
>
> if (size<16384) size=16384;
>
> size = ((size+page_size-1)/page_size)*page_size;
> int res = pthread_attr_setstacksize(&val_, size);
> ((void)(!res && "pthread_attr_setstacksize failed"));
> }
>
> std::size_t get_stack_size() const noexcept {
> std::size_t size;
> int res = pthread_attr_getstacksize(&val_, &size);
> ((void)(!res && "pthread_attr_getstacksize failed"));
> return size;
> }
>
>
> typedef pthread_attr_t native_handle_type;
> native_handle_type* native_handle() noexcept {
> return &val_;
> }
> const native_handle_type* native_handle() const noexcept {
> return &val_;
> }
>
> private:
> pthread_attr_t val_;
> };
>
> class thread;
>
> namespace detail
> {
> struct future_object_base;
> struct tss_cleanup_function;
> struct thread_exit_callback_node;
> struct tss_data_node
> {
> boost::shared_ptr<boost::detail::tss_cleanup_function> func;
> void* value;
>
> tss_data_node(boost::shared_ptr<boost::detail::tss_cleanup_function> func_,
> void* value_):
> func(func_),value(value_)
> {}
> };
>
> struct thread_data_base;
> typedef boost::shared_ptr<thread_data_base> thread_data_ptr;
>
> struct __attribute__((__visibility__("default"))) thread_data_base:
> enable_shared_from_this<thread_data_base>
> {
> thread_data_ptr self;
> pthread_t thread_handle;
> boost::mutex data_mutex;
> boost::condition_variable done_condition;
> boost::mutex sleep_mutex;
> boost::condition_variable sleep_condition;
> bool done;
> bool join_started;
> bool joined;
> boost::detail::thread_exit_callback_node* thread_exit_callbacks;
> std::map<void const*,boost::detail::tss_data_node> tss_data;
>
> pthread_mutex_t* cond_mutex;
> pthread_cond_t* current_cond;
> typedef std::vector<std::pair<condition_variable*, mutex*>
>
> > notify_list_t;
> notify_list_t notify;
>
> typedef std::vector<shared_ptr<future_object_base> > async_states_t;
> async_states_t async_states_;
>
>
>
>
>
> bool interrupt_enabled;
> bool interrupt_requested;
>
> thread_data_base():
> thread_handle(0),
> done(false),join_started(false),joined(false),
> thread_exit_callbacks(0),
> cond_mutex(0),
> current_cond(0),
> notify(),
> async_states_()
>
> , interrupt_enabled(true)
> , interrupt_requested(false)
>
> {}
> virtual ~thread_data_base();
>
> typedef pthread_t native_handle_type;
>
> virtual void run()=0;
> virtual void notify_all_at_thread_exit(condition_variable* cv, mutex* m)
> {
> notify.push_back(std::pair<condition_variable*, mutex*>(cv, m));
> }
>
> void make_ready_at_thread_exit(shared_ptr<future_object_base> as)
> {
> async_states_.push_back(as);
> }
>
> };
>
> __attribute__((__visibility__("default"))) thread_data_base* get_current_thread_data();
>
>
> class interruption_checker
> {
> thread_data_base* const thread_info;
> pthread_mutex_t* m;
> bool set;
>
> void check_for_interruption()
> {
>
> if(thread_info->interrupt_requested)
> {
> thread_info->interrupt_requested=false;
> throw thread_interrupted();
> }
>
> }
>
> void operator=(interruption_checker&);
> public:
> explicit interruption_checker(pthread_mutex_t* cond_mutex,pthread_cond_t* cond):
> thread_info(detail::get_current_thread_data()),m(cond_mutex),
> set(thread_info && thread_info->interrupt_enabled)
> {
> if(set)
> {
> lock_guard<mutex> guard(thread_info->data_mutex);
> check_for_interruption();
> thread_info->cond_mutex=cond_mutex;
> thread_info->current_cond=cond;
> ((void)(!pthread_mutex_lock(m)));
> }
> else
> {
> ((void)(!pthread_mutex_lock(m)));
> }
> }
> ~interruption_checker()
> {
> if(set)
> {
> ((void)(!pthread_mutex_unlock(m)));
> lock_guard<mutex> guard(thread_info->data_mutex);
> thread_info->cond_mutex=__null;
> thread_info->current_cond=__null;
> }
> else
> {
> ((void)(!pthread_mutex_unlock(m)));
> }
> }
> };
>
> }
>
> namespace this_thread
> {
> namespace hiden
> {
> void __attribute__((__visibility__("default"))) sleep_for(const timespec& ts);
> void __attribute__((__visibility__("default"))) sleep_until(const timespec& ts);
> }
>
>
>
>
> inline
> void __attribute__((__visibility__("default"))) sleep_for(const chrono::nanoseconds& ns)
> {
> return boost::this_thread::hiden::sleep_for(boost::detail::to_timespec(ns));
> }
>
>
>
> void __attribute__((__visibility__("default"))) yield() noexcept;
>
>
>
>
>
>
> inline void sleep(system_time const& abs_time)
> {
> return boost::this_thread::hiden::sleep_until(boost::detail::to_timespec(abs_time));
> }
>
> template<typename TimeDuration>
> inline __attribute__((__visibility__("default"))) void sleep(TimeDuration const& rel_time)
> {
> this_thread::sleep(get_system_time()+rel_time);
> }
>
> }
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 262 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
># 18 "/usr/include/boost/thread/thread_only.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/thread/detail/thread.hpp" 1 3 4
># 20 "/usr/include/boost/thread/detail/thread.hpp" 3 4
># 1 "/usr/include/boost/thread/detail/thread_heap_alloc.hpp" 1 3 4
># 17 "/usr/include/boost/thread/detail/thread_heap_alloc.hpp" 3 4
># 1 "/usr/include/boost/thread/pthread/thread_heap_alloc.hpp" 1 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 9 "/usr/include/boost/thread/pthread/thread_heap_alloc.hpp" 2 3 4
>
>namespace boost
>{
> namespace detail
> {
> template<typename T>
> inline T* heap_new()
> {
> return new T();
> }
>
>
> template<typename T,typename A1>
> inline T* heap_new(A1&& a1)
> {
> return new T(static_cast<A1&&>(a1));
> }
> template<typename T,typename A1,typename A2>
> inline T* heap_new(A1&& a1,A2&& a2)
> {
> return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2));
> }
> template<typename T,typename A1,typename A2,typename A3>
> inline T* heap_new(A1&& a1,A2&& a2,A3&& a3)
> {
> return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
> static_cast<A3&&>(a3));
> }
> template<typename T,typename A1,typename A2,typename A3,typename A4>
> inline T* heap_new(A1&& a1,A2&& a2,A3&& a3,A4&& a4)
> {
> return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
> static_cast<A3&&>(a3),static_cast<A4&&>(a4));
> }
># 223 "/usr/include/boost/thread/pthread/thread_heap_alloc.hpp" 3 4
> template<typename T>
> inline void heap_delete(T* data)
> {
> delete data;
> }
>
> template<typename T>
> struct do_heap_delete
> {
> void operator()(T* data) const
> {
> detail::heap_delete(data);
> }
> };
> }
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 241 "/usr/include/boost/thread/pthread/thread_heap_alloc.hpp" 2 3 4
># 18 "/usr/include/boost/thread/detail/thread_heap_alloc.hpp" 2 3 4
># 21 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4
># 1 "/usr/include/boost/thread/detail/make_tuple_indices.hpp" 1 3 4
># 27 "/usr/include/boost/thread/detail/make_tuple_indices.hpp" 3 4
>namespace boost
>{
> namespace detail
> {
>
>
>
>
> template <std::size_t...> struct tuple_indices
> {};
>
> template <std::size_t Sp, class IntTuple, std::size_t Ep>
> struct make_indices_imp;
>
> template <std::size_t Sp, std::size_t ...Indices, std::size_t Ep>
> struct make_indices_imp<Sp, tuple_indices<Indices...>, Ep>
> {
> typedef typename make_indices_imp<Sp+1, tuple_indices<Indices..., Sp>, Ep>::type type;
> };
>
> template <std::size_t Ep, std::size_t ...Indices>
> struct make_indices_imp<Ep, tuple_indices<Indices...>, Ep>
> {
> typedef tuple_indices<Indices...> type;
> };
>
> template <std::size_t Ep, std::size_t Sp = 0>
> struct make_tuple_indices
> {
> static_assert(Sp <= Ep, "make_tuple_indices input error");
> typedef typename make_indices_imp<Sp, tuple_indices<>, Ep>::type type;
> };
># 221 "/usr/include/boost/thread/detail/make_tuple_indices.hpp" 3 4
> }
>}
># 22 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4
># 1 "/usr/include/boost/thread/detail/invoke.hpp" 1 3 4
># 37 "/usr/include/boost/thread/detail/invoke.hpp" 3 4
>namespace boost
>{
> namespace detail
> {
># 54 "/usr/include/boost/thread/detail/invoke.hpp" 3 4
> template <class Fp, class A0, class ...Args>
> inline auto
> invoke(Fp && f, A0 && a0, Args && ...args)
> -> decltype((boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...))
> {
> return (boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...);
> }
>
> template <class Fp, class A0, class ...Args>
> inline auto
> invoke(Fp && f, A0 && a0, Args && ...args)
> -> decltype(((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...))
> {
> return ((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...);
> }
>
>
>
> template <class Fp, class A0>
> inline auto
> invoke(Fp && f, A0 && a0)
> -> decltype(boost::forward<A0>(a0).*f)
> {
> return boost::forward<A0>(a0).*f;
> }
>
> template <class Fp, class A0>
> inline auto
> invoke(Fp && f, A0 && a0)
> -> decltype((*boost::forward<A0>(a0)).*f)
> {
> return (*boost::forward<A0>(a0)).*f;
> }
>
>
>
> template <class Fp, class ...Args>
> inline auto invoke(Fp && f, Args && ...args)
> -> decltype(boost::forward<Fp>(f)(boost::forward<Args>(args)...))
> {
> return boost::forward<Fp>(f)(boost::forward<Args>(args)...);
> }
># 1348 "/usr/include/boost/thread/detail/invoke.hpp" 3 4
> }
> }
># 23 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4
># 1 "/usr/include/boost/thread/detail/is_convertible.hpp" 1 3 4
># 17 "/usr/include/boost/thread/detail/is_convertible.hpp" 3 4
>namespace boost
>{
> namespace thread_detail
> {
> template <typename T1, typename T2>
> struct is_convertible : boost::is_convertible<T1,T2> {};
># 43 "/usr/include/boost/thread/detail/is_convertible.hpp" 3 4
> }
>
>}
># 24 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 25 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 29 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4
># 37 "/usr/include/boost/thread/detail/thread.hpp" 3 4
># 1 "/usr/include/boost/functional/hash.hpp" 1 3 4
>
>
>
>
>
># 1 "/usr/include/boost/functional/hash/hash.hpp" 1 3 4
># 15 "/usr/include/boost/functional/hash/hash.hpp" 3 4
># 1 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 1 3 4
># 14 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 3 4
># 1 "/usr/include/boost/functional/hash/detail/float_functions.hpp" 1 3 4
># 76 "/usr/include/boost/functional/hash/detail/float_functions.hpp" 3 4
>namespace boost {
> namespace hash_detail {
> template <typename Float>
> struct call_ldexp {
> typedef Float float_type;
> inline Float operator()(Float x, int y) const {
> return std::ldexp(x, y);
> }
> };
>
> template <typename Float>
> struct call_frexp {
> typedef Float float_type;
> inline Float operator()(Float x, int* y) const {
> return std::frexp(x, y);
> }
> };
>
> template <typename Float>
> struct select_hash_type
> {
> typedef Float type;
> };
> }
>}
># 15 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 2 3 4
># 1 "/usr/include/boost/functional/hash/detail/limits.hpp" 1 3 4
># 26 "/usr/include/boost/functional/hash/detail/limits.hpp" 3 4
>namespace boost
>{
> namespace hash_detail
> {
> template <class T>
> struct limits : std::numeric_limits<T> {};
># 58 "/usr/include/boost/functional/hash/detail/limits.hpp" 3 4
> }
>}
># 16 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 2 3 4
>
># 1 "/usr/include/boost/integer/static_log2.hpp" 1 3 4
># 19 "/usr/include/boost/integer/static_log2.hpp" 3 4
># 1 "/usr/include/boost/integer_fwd.hpp" 1 3 4
># 12 "/usr/include/boost/integer_fwd.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/climits" 1 3 4
># 39 "/usr/include/c++/4.8.2/climits" 3 4
> 
># 40 "/usr/include/c++/4.8.2/climits" 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/climits" 2 3
># 13 "/usr/include/boost/integer_fwd.hpp" 2 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 14 "/usr/include/boost/integer_fwd.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 18 "/usr/include/boost/integer_fwd.hpp" 2 3 4
>
>
>namespace boost
>{
>
>
>
>
>
>
>
> typedef boost::uintmax_t static_min_max_unsigned_type;
> typedef boost::intmax_t static_min_max_signed_type;
> typedef boost::uintmax_t static_log2_argument_type;
> typedef int static_log2_result_type;
># 42 "/usr/include/boost/integer_fwd.hpp" 3 4
>template < class T >
> class integer_traits;
>
>template < >
> class integer_traits< bool >;
>
>template < >
> class integer_traits< char >;
>
>template < >
> class integer_traits< signed char >;
>
>template < >
> class integer_traits< unsigned char >;
>
>
>template < >
> class integer_traits< wchar_t >;
>
>
>template < >
> class integer_traits< short >;
>
>template < >
> class integer_traits< unsigned short >;
>
>template < >
> class integer_traits< int >;
>
>template < >
> class integer_traits< unsigned int >;
>
>template < >
> class integer_traits< long >;
>
>template < >
> class integer_traits< unsigned long >;
>
>
>template < >
>class integer_traits< ::boost::long_long_type>;
>
>template < >
>class integer_traits< ::boost::ulong_long_type >;
># 97 "/usr/include/boost/integer_fwd.hpp" 3 4
>template < typename LeastInt >
> struct int_fast_t;
>
>template< int Bits >
> struct int_t;
>
>template< int Bits >
> struct uint_t;
>
>
> template< boost::long_long_type MaxValue >
>
>
>
> struct int_max_value_t;
>
>
> template< boost::long_long_type MinValue >
>
>
>
> struct int_min_value_t;
>
>
> template< boost::ulong_long_type MaxValue >
>
>
>
> struct uint_value_t;
>
>
>
>
>template < std::size_t Bit >
> struct high_bit_mask_t;
>
>template < std::size_t Bits >
> struct low_bits_mask_t;
>
>template < >
> struct low_bits_mask_t< ::std::numeric_limits<unsigned char>::digits >;
>
>
>
>template <static_log2_argument_type Value >
> struct static_log2;
>
>template <> struct static_log2<0u>;
>
>
>
>
>template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
> struct static_signed_min;
>
>template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
> struct static_signed_max;
>
>template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
> struct static_unsigned_min;
>
>template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
> struct static_unsigned_max;
>
>}
># 20 "/usr/include/boost/integer/static_log2.hpp" 2 3 4
>
>namespace boost {
>
> namespace detail {
>
> namespace static_log2_impl {
># 44 "/usr/include/boost/integer/static_log2.hpp" 3 4
> typedef boost::static_log2_argument_type argument_type;
> typedef boost::static_log2_result_type result_type;
>
> template <result_type n>
> struct choose_initial_n {
>
> static const bool c = (argument_type(1) << n << n) != 0;
> static const result_type value = !c*n + choose_initial_n<2*c*n>::value
>
>
> ;
>
> };
>
> template <>
> struct choose_initial_n<0> {
> static const result_type value = 0;
> };
>
>
>
>
> const result_type n_zero = 16;
> const result_type initial_n = choose_initial_n<n_zero>::value;
># 84 "/usr/include/boost/integer/static_log2.hpp" 3 4
> template <argument_type x, result_type n = initial_n>
> struct static_log2_impl {
>
> static const bool c = (x >> n) > 0;
> static const result_type value = c*n + (static_log2_impl< (x>>c*n), n/2 >::value)
>
>
> ;
>
> };
>
> template <>
> struct static_log2_impl<1, 0> {
> static const result_type value = 0;
> };
>
> }
> }
>
>
>
>
>
>
>
> template <static_log2_argument_type x>
> struct static_log2 {
>
> static const static_log2_result_type value = detail::static_log2_impl::static_log2_impl<x>::value
>
>
> ;
>
> };
>
>
> template <>
> struct static_log2<0> { };
>
>}
># 18 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 2 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 19 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 2 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 20 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 2 3 4
>
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 22 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 2 3 4
># 51 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 3 4
>namespace boost
>{
> namespace hash_detail
> {
> inline void hash_float_combine(std::size_t& seed, std::size_t value)
> {
> seed ^= value + (seed<<6) + (seed>>2);
> }
>
>
>
>
>
>
>
> inline std::size_t hash_binary(char* ptr, std::size_t length)
> {
> std::size_t seed = 0;
>
> if (length >= sizeof(std::size_t)) {
> seed = *(std::size_t*) ptr;
> length -= sizeof(std::size_t);
> ptr += sizeof(std::size_t);
>
> while(length >= sizeof(std::size_t)) {
> std::size_t buffer = 0;
> std::memcpy(&buffer, ptr, sizeof(std::size_t));
> hash_float_combine(seed, buffer);
> length -= sizeof(std::size_t);
> ptr += sizeof(std::size_t);
> }
> }
>
> if (length > 0) {
> std::size_t buffer = 0;
> std::memcpy(&buffer, ptr, length);
> hash_float_combine(seed, buffer);
> }
>
> return seed;
> }
>
> template <typename Float>
> inline std::size_t float_hash_impl(Float v,
> typename boost::enable_if_c<
> std::numeric_limits<Float>::is_iec559 &&
> std::numeric_limits<Float>::digits == 24 &&
> std::numeric_limits<Float>::radix == 2 &&
> std::numeric_limits<Float>::max_exponent == 128,
> int>::type
> )
> {
> return hash_binary((char*) &v, 4);
> }
>
>
> template <typename Float>
> inline std::size_t float_hash_impl(Float v,
> typename boost::enable_if_c<
> std::numeric_limits<Float>::is_iec559 &&
> std::numeric_limits<Float>::digits == 53 &&
> std::numeric_limits<Float>::radix == 2 &&
> std::numeric_limits<Float>::max_exponent == 1024,
> int>::type
> )
> {
> return hash_binary((char*) &v, 8);
> }
>
> template <typename Float>
> inline std::size_t float_hash_impl(Float v,
> typename boost::enable_if_c<
> std::numeric_limits<Float>::is_iec559 &&
> std::numeric_limits<Float>::digits == 64 &&
> std::numeric_limits<Float>::radix == 2 &&
> std::numeric_limits<Float>::max_exponent == 16384,
> int>::type
> )
> {
> return hash_binary((char*) &v, 10);
> }
>
> template <typename Float>
> inline std::size_t float_hash_impl(Float v,
> typename boost::enable_if_c<
> std::numeric_limits<Float>::is_iec559 &&
> std::numeric_limits<Float>::digits == 113 &&
> std::numeric_limits<Float>::radix == 2 &&
> std::numeric_limits<Float>::max_exponent == 16384,
> int>::type
> )
> {
> return hash_binary((char*) &v, 16);
> }
>
>
>
>
>
>
> template <class T>
> inline std::size_t float_hash_impl2(T v)
> {
> boost::hash_detail::call_frexp<T> frexp;
> boost::hash_detail::call_ldexp<T> ldexp;
>
> int exp = 0;
>
> v = frexp(v, &exp);
>
>
>
> if(v < 0) {
> v = -v;
> exp += limits<T>::max_exponent -
> limits<T>::min_exponent;
> }
>
> v = ldexp(v, limits<std::size_t>::digits);
> std::size_t seed = static_cast<std::size_t>(v);
> v -= static_cast<T>(seed);
>
>
> std::size_t const length
> = (limits<T>::digits *
> boost::static_log2<limits<T>::radix>::value
> + limits<std::size_t>::digits - 1)
> / limits<std::size_t>::digits;
>
> for(std::size_t i = 0; i != length; ++i)
> {
> v = ldexp(v, limits<std::size_t>::digits);
> std::size_t part = static_cast<std::size_t>(v);
> v -= static_cast<T>(part);
> hash_float_combine(seed, part);
> }
>
> hash_float_combine(seed, exp);
>
> return seed;
> }
>
>
> template <class T>
> inline std::size_t float_hash_impl(T v, ...)
> {
> typedef typename select_hash_type<T>::type type;
> return float_hash_impl2(static_cast<type>(v));
> }
>
> }
>}
>
>
>
>
>
>namespace boost
>{
> namespace hash_detail
> {
> template <class T>
> inline std::size_t float_hash_value(T v)
> {
>
>
>
> switch (std::fpclassify(v))
>
>
>
>
> {
> case 2:
> return 0;
> case 1:
> return (std::size_t)(v > 0 ? -1 : -2);
> case 0:
> return (std::size_t)(-3);
> case 4:
> case 3:
> return float_hash_impl(v, 0);
> default:
> ((void)0);
> return 0;
> }
> }
> }
>}
># 16 "/usr/include/boost/functional/hash/hash.hpp" 2 3 4
># 27 "/usr/include/boost/functional/hash/hash.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/typeindex" 1 3 4
># 32 "/usr/include/c++/4.8.2/typeindex" 3 4
> 
># 33 "/usr/include/c++/4.8.2/typeindex" 3
>
>
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 52 "/usr/include/c++/4.8.2/typeindex" 3
> struct type_index
> {
> type_index(const type_info& __rhs) noexcept
> : _M_target(&__rhs) { }
>
> bool
> operator==(const type_index& __rhs) const noexcept
> { return *_M_target == *__rhs._M_target; }
>
> bool
> operator!=(const type_index& __rhs) const noexcept
> { return *_M_target != *__rhs._M_target; }
>
> bool
> operator<(const type_index& __rhs) const noexcept
> { return _M_target->before(*__rhs._M_target); }
>
> bool
> operator<=(const type_index& __rhs) const noexcept
> { return !__rhs._M_target->before(*_M_target); }
>
> bool
> operator>(const type_index& __rhs) const noexcept
> { return __rhs._M_target->before(*_M_target); }
>
> bool
> operator>=(const type_index& __rhs) const noexcept
> { return !_M_target->before(*__rhs._M_target); }
>
> size_t
> hash_code() const noexcept
> { return _M_target->hash_code(); }
>
> const char*
> name() const
> { return _M_target->name(); }
>
> private:
> const type_info* _M_target;
> };
>
> template<typename _Tp> struct hash;
>
>
> template<>
> struct hash<type_index>
> {
> typedef size_t result_type;
> typedef type_index argument_type;
>
> size_t
> operator()(const type_index& __ti) const noexcept
> { return __ti.hash_code(); }
> };
>
>
>}
># 28 "/usr/include/boost/functional/hash/hash.hpp" 2 3 4
># 37 "/usr/include/boost/functional/hash/hash.hpp" 3 4
>namespace boost
>{
> namespace hash_detail
> {
> struct enable_hash_value { typedef std::size_t type; };
>
> template <typename T> struct basic_numbers {};
> template <typename T> struct long_numbers;
> template <typename T> struct ulong_numbers;
> template <typename T> struct float_numbers {};
>
> template <> struct basic_numbers<bool> :
> boost::hash_detail::enable_hash_value {};
> template <> struct basic_numbers<char> :
> boost::hash_detail::enable_hash_value {};
> template <> struct basic_numbers<unsigned char> :
> boost::hash_detail::enable_hash_value {};
> template <> struct basic_numbers<signed char> :
> boost::hash_detail::enable_hash_value {};
> template <> struct basic_numbers<short> :
> boost::hash_detail::enable_hash_value {};
> template <> struct basic_numbers<unsigned short> :
> boost::hash_detail::enable_hash_value {};
> template <> struct basic_numbers<int> :
> boost::hash_detail::enable_hash_value {};
> template <> struct basic_numbers<unsigned int> :
> boost::hash_detail::enable_hash_value {};
> template <> struct basic_numbers<long> :
> boost::hash_detail::enable_hash_value {};
> template <> struct basic_numbers<unsigned long> :
> boost::hash_detail::enable_hash_value {};
>
>
> template <> struct basic_numbers<wchar_t> :
> boost::hash_detail::enable_hash_value {};
>
>
>
>
>
> template <typename T> struct long_numbers2 {};
> template <typename T> struct ulong_numbers2 {};
> template <typename T> struct long_numbers : long_numbers2<T> {};
> template <typename T> struct ulong_numbers : ulong_numbers2<T> {};
>
>
> template <> struct long_numbers<boost::long_long_type> :
> boost::hash_detail::enable_hash_value {};
> template <> struct ulong_numbers<boost::ulong_long_type> :
> boost::hash_detail::enable_hash_value {};
>
>
>
> template <> struct long_numbers2<boost::int128_type> :
> boost::hash_detail::enable_hash_value {};
> template <> struct ulong_numbers2<boost::uint128_type> :
> boost::hash_detail::enable_hash_value {};
>
>
> template <> struct float_numbers<float> :
> boost::hash_detail::enable_hash_value {};
> template <> struct float_numbers<double> :
> boost::hash_detail::enable_hash_value {};
> template <> struct float_numbers<long double> :
> boost::hash_detail::enable_hash_value {};
> }
>
> template <typename T>
> typename boost::hash_detail::basic_numbers<T>::type hash_value(T);
> template <typename T>
> typename boost::hash_detail::long_numbers<T>::type hash_value(T);
> template <typename T>
> typename boost::hash_detail::ulong_numbers<T>::type hash_value(T);
>
> template <typename T>
> typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
> hash_value(T);
>
>
> template <class T> std::size_t hash_value(T* const&);
>
>
>
>
>
> template< class T, unsigned N >
> std::size_t hash_value(const T (&x)[N]);
>
> template< class T, unsigned N >
> std::size_t hash_value(T (&x)[N]);
>
>
> template <class Ch, class A>
> std::size_t hash_value(
> std::basic_string<Ch, std::char_traits<Ch>, A> const&);
>
> template <typename T>
> typename boost::hash_detail::float_numbers<T>::type hash_value(T);
>
>
> std::size_t hash_value(std::type_index);
>
>
>
>
> namespace hash_detail
> {
> template <class T>
> inline std::size_t hash_value_signed(T val)
> {
> const int size_t_bits = std::numeric_limits<std::size_t>::digits;
>
> const int length = (std::numeric_limits<T>::digits - 1)
> / size_t_bits;
>
> std::size_t seed = 0;
> T positive = val < 0 ? -1 - val : val;
>
>
> for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
> {
> seed ^= (std::size_t) (positive >> i) + (seed<<6) + (seed>>2);
> }
> seed ^= (std::size_t) val + (seed<<6) + (seed>>2);
>
> return seed;
> }
>
> template <class T>
> inline std::size_t hash_value_unsigned(T val)
> {
> const int size_t_bits = std::numeric_limits<std::size_t>::digits;
>
> const int length = (std::numeric_limits<T>::digits - 1)
> / size_t_bits;
>
> std::size_t seed = 0;
>
>
> for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
> {
> seed ^= (std::size_t) (val >> i) + (seed<<6) + (seed>>2);
> }
> seed ^= (std::size_t) val + (seed<<6) + (seed>>2);
>
> return seed;
> }
> }
>
> template <typename T>
> typename boost::hash_detail::basic_numbers<T>::type hash_value(T v)
> {
> return static_cast<std::size_t>(v);
> }
>
> template <typename T>
> typename boost::hash_detail::long_numbers<T>::type hash_value(T v)
> {
> return hash_detail::hash_value_signed(v);
> }
>
> template <typename T>
> typename boost::hash_detail::ulong_numbers<T>::type hash_value(T v)
> {
> return hash_detail::hash_value_unsigned(v);
> }
>
> template <typename T>
> typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
> hash_value(T v)
> {
> return static_cast<std::size_t>(v);
> }
>
>
>
> template <class T> std::size_t hash_value(T* const& v)
>
>
>
> {
>
>
>
>
>
>
> std::size_t x = static_cast<std::size_t>(
> reinterpret_cast<std::ptrdiff_t>(v));
>
> return x + (x >> 3);
> }
># 244 "/usr/include/boost/functional/hash/hash.hpp" 3 4
> template <class T>
> inline void hash_combine(std::size_t& seed, T const& v)
>
> {
> boost::hash<T> hasher;
> seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
> }
>
>
>
>
>
> template <class It>
> inline std::size_t hash_range(It first, It last)
> {
> std::size_t seed = 0;
>
> for(; first != last; ++first)
> {
> hash_combine(seed, *first);
> }
>
> return seed;
> }
>
> template <class It>
> inline void hash_range(std::size_t& seed, It first, It last)
> {
> for(; first != last; ++first)
> {
> hash_combine(seed, *first);
> }
> }
># 305 "/usr/include/boost/functional/hash/hash.hpp" 3 4
> template< class T, unsigned N >
> inline std::size_t hash_value(const T (&x)[N])
> {
> return hash_range(x, x + N);
> }
>
> template< class T, unsigned N >
> inline std::size_t hash_value(T (&x)[N])
> {
> return hash_range(x, x + N);
> }
>
>
> template <class Ch, class A>
> inline std::size_t hash_value(
> std::basic_string<Ch, std::char_traits<Ch>, A> const& v)
> {
> return hash_range(v.begin(), v.end());
> }
>
> template <typename T>
> typename boost::hash_detail::float_numbers<T>::type hash_value(T v)
> {
> return boost::hash_detail::float_hash_value(v);
> }
>
>
> inline std::size_t hash_value(std::type_index v)
> {
> return v.hash_code();
> }
># 414 "/usr/include/boost/functional/hash/hash.hpp" 3 4
> template <> struct hash<bool> : public std::unary_function<bool, std::size_t> { std::size_t operator()(bool v) const { return boost::hash_value(v); } };
> template <> struct hash<char> : public std::unary_function<char, std::size_t> { std::size_t operator()(char v) const { return boost::hash_value(v); } };
> template <> struct hash<signed char> : public std::unary_function<signed char, std::size_t> { std::size_t operator()(signed char v) const { return boost::hash_value(v); } };
> template <> struct hash<unsigned char> : public std::unary_function<unsigned char, std::size_t> { std::size_t operator()(unsigned char v) const { return boost::hash_value(v); } };
>
> template <> struct hash<wchar_t> : public std::unary_function<wchar_t, std::size_t> { std::size_t operator()(wchar_t v) const { return boost::hash_value(v); } };
>
> template <> struct hash<short> : public std::unary_function<short, std::size_t> { std::size_t operator()(short v) const { return boost::hash_value(v); } };
> template <> struct hash<unsigned short> : public std::unary_function<unsigned short, std::size_t> { std::size_t operator()(unsigned short v) const { return boost::hash_value(v); } };
> template <> struct hash<int> : public std::unary_function<int, std::size_t> { std::size_t operator()(int v) const { return boost::hash_value(v); } };
> template <> struct hash<unsigned int> : public std::unary_function<unsigned int, std::size_t> { std::size_t operator()(unsigned int v) const { return boost::hash_value(v); } };
> template <> struct hash<long> : public std::unary_function<long, std::size_t> { std::size_t operator()(long v) const { return boost::hash_value(v); } };
> template <> struct hash<unsigned long> : public std::unary_function<unsigned long, std::size_t> { std::size_t operator()(unsigned long v) const { return boost::hash_value(v); } };
>
> template <> struct hash<float> : public std::unary_function<float, std::size_t> { std::size_t operator()(float v) const { return boost::hash_value(v); } };
> template <> struct hash<double> : public std::unary_function<double, std::size_t> { std::size_t operator()(double v) const { return boost::hash_value(v); } };
> template <> struct hash<long double> : public std::unary_function<long double, std::size_t> { std::size_t operator()(long double v) const { return boost::hash_value(v); } };
>
> template <> struct hash<std::string> : public std::unary_function<std::string, std::size_t> { std::size_t operator()(std::string const& v) const { return boost::hash_value(v); } };
>
> template <> struct hash<std::wstring> : public std::unary_function<std::wstring, std::size_t> { std::size_t operator()(std::wstring const& v) const { return boost::hash_value(v); } };
>
>
>
> template <> struct hash<boost::long_long_type> : public std::unary_function<boost::long_long_type, std::size_t> { std::size_t operator()(boost::long_long_type v) const { return boost::hash_value(v); } };
> template <> struct hash<boost::ulong_long_type> : public std::unary_function<boost::ulong_long_type, std::size_t> { std::size_t operator()(boost::ulong_long_type v) const { return boost::hash_value(v); } };
>
>
>
> template <> struct hash<boost::int128_type> : public std::unary_function<boost::int128_type, std::size_t> { std::size_t operator()(boost::int128_type v) const { return boost::hash_value(v); } };
> template <> struct hash<boost::uint128_type> : public std::unary_function<boost::uint128_type, std::size_t> { std::size_t operator()(boost::uint128_type v) const { return boost::hash_value(v); } };
>
>
>
> template <> struct hash<std::type_index> : public std::unary_function<std::type_index, std::size_t> { std::size_t operator()(std::type_index v) const { return boost::hash_value(v); } };
># 458 "/usr/include/boost/functional/hash/hash.hpp" 3 4
> template <class T>
> struct hash<T*>
> : public std::unary_function<T*, std::size_t>
> {
> std::size_t operator()(T* v) const
> {
>
> return boost::hash_value(v);
>
>
>
>
>
>
> }
> };
># 517 "/usr/include/boost/functional/hash/hash.hpp" 3 4
>}
># 529 "/usr/include/boost/functional/hash/hash.hpp" 3 4
># 1 "/usr/include/boost/functional/hash/extensions.hpp" 1 3 4
># 16 "/usr/include/boost/functional/hash/extensions.hpp" 3 4
># 1 "/usr/include/boost/functional/hash/hash.hpp" 1 3 4
># 17 "/usr/include/boost/functional/hash/extensions.hpp" 2 3 4
># 1 "/usr/include/boost/detail/container_fwd.hpp" 1 3 4
># 95 "/usr/include/boost/detail/container_fwd.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/set" 1 3 4
># 58 "/usr/include/c++/4.8.2/set" 3 4
> 
># 59 "/usr/include/c++/4.8.2/set" 3
>
>
># 1 "/usr/include/c++/4.8.2/bits/stl_set.h" 1 3
># 64 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 88 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> template<typename _Key, typename _Compare = std::less<_Key>,
> typename _Alloc = std::allocator<_Key> >
> class set
> {
>
> typedef typename _Alloc::value_type _Alloc_value_type;
> 
> 
>
> 
>
> public:
>
>
>
> typedef _Key key_type;
> typedef _Key value_type;
> typedef _Compare key_compare;
> typedef _Compare value_compare;
> typedef _Alloc allocator_type;
>
>
> private:
> typedef typename _Alloc::template rebind<_Key>::other _Key_alloc_type;
>
> typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
> key_compare, _Key_alloc_type> _Rep_type;
> _Rep_type _M_t;
>
> public:
>
>
> typedef typename _Key_alloc_type::pointer pointer;
> typedef typename _Key_alloc_type::const_pointer const_pointer;
> typedef typename _Key_alloc_type::reference reference;
> typedef typename _Key_alloc_type::const_reference const_reference;
>
>
>
> typedef typename _Rep_type::const_iterator iterator;
> typedef typename _Rep_type::const_iterator const_iterator;
> typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
> typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
> typedef typename _Rep_type::size_type size_type;
> typedef typename _Rep_type::difference_type difference_type;
>
>
>
>
>
>
> set()
> : _M_t() { }
>
>
>
>
>
>
> explicit
> set(const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Key_alloc_type(__a)) { }
># 162 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> template<typename _InputIterator>
> set(_InputIterator __first, _InputIterator __last)
> : _M_t()
> { _M_t._M_insert_unique(__first, __last); }
># 179 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> template<typename _InputIterator>
> set(_InputIterator __first, _InputIterator __last,
> const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Key_alloc_type(__a))
> { _M_t._M_insert_unique(__first, __last); }
># 193 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> set(const set& __x)
> : _M_t(__x._M_t) { }
># 204 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> set(set&& __x)
> noexcept(is_nothrow_copy_constructible<_Compare>::value)
> : _M_t(std::move(__x._M_t)) { }
># 218 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> set(initializer_list<value_type> __l,
> const _Compare& __comp = _Compare(),
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Key_alloc_type(__a))
> { _M_t._M_insert_unique(__l.begin(), __l.end()); }
># 232 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> set&
> operator=(const set& __x)
> {
> _M_t = __x._M_t;
> return *this;
> }
># 247 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> set&
> operator=(set&& __x)
> {
>
>
> this->clear();
> this->swap(__x);
> return *this;
> }
># 268 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> set&
> operator=(initializer_list<value_type> __l)
> {
> this->clear();
> this->insert(__l.begin(), __l.end());
> return *this;
> }
>
>
>
>
>
> key_compare
> key_comp() const
> { return _M_t.key_comp(); }
>
> value_compare
> value_comp() const
> { return _M_t.key_comp(); }
>
> allocator_type
> get_allocator() const noexcept
> { return allocator_type(_M_t.get_allocator()); }
>
>
>
>
>
>
> iterator
> begin() const noexcept
> { return _M_t.begin(); }
>
>
>
>
>
>
> iterator
> end() const noexcept
> { return _M_t.end(); }
>
>
>
>
>
>
> reverse_iterator
> rbegin() const noexcept
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> reverse_iterator
> rend() const noexcept
> { return _M_t.rend(); }
>
>
>
>
>
>
>
> iterator
> cbegin() const noexcept
> { return _M_t.begin(); }
>
>
>
>
>
>
> iterator
> cend() const noexcept
> { return _M_t.end(); }
>
>
>
>
>
>
> reverse_iterator
> crbegin() const noexcept
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> reverse_iterator
> crend() const noexcept
> { return _M_t.rend(); }
>
>
>
> bool
> empty() const noexcept
> { return _M_t.empty(); }
>
>
> size_type
> size() const noexcept
> { return _M_t.size(); }
>
>
> size_type
> max_size() const noexcept
> { return _M_t.max_size(); }
># 392 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> void
> swap(set& __x)
> { _M_t.swap(__x._M_t); }
># 411 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> template<typename... _Args>
> std::pair<iterator, bool>
> emplace(_Args&&... __args)
> { return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); }
># 437 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> template<typename... _Args>
> iterator
> emplace_hint(const_iterator __pos, _Args&&... __args)
> {
> return _M_t._M_emplace_hint_unique(__pos,
> std::forward<_Args>(__args)...);
> }
># 459 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> std::pair<iterator, bool>
> insert(const value_type& __x)
> {
> std::pair<typename _Rep_type::iterator, bool> __p =
> _M_t._M_insert_unique(__x);
> return std::pair<iterator, bool>(__p.first, __p.second);
> }
>
>
> std::pair<iterator, bool>
> insert(value_type&& __x)
> {
> std::pair<typename _Rep_type::iterator, bool> __p =
> _M_t._M_insert_unique(std::move(__x));
> return std::pair<iterator, bool>(__p.first, __p.second);
> }
># 496 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> iterator
> insert(const_iterator __position, const value_type& __x)
> { return _M_t._M_insert_unique_(__position, __x); }
>
>
> iterator
> insert(const_iterator __position, value_type&& __x)
> { return _M_t._M_insert_unique_(__position, std::move(__x)); }
># 515 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> template<typename _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_t._M_insert_unique(__first, __last); }
># 528 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> void
> insert(initializer_list<value_type> __l)
> { this->insert(__l.begin(), __l.end()); }
># 549 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> __attribute ((__abi_tag__ ("cxx11")))
> iterator
> erase(const_iterator __position)
> { return _M_t.erase(__position); }
># 580 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> size_type
> erase(const key_type& __x)
> { return _M_t.erase(__x); }
># 601 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> __attribute ((__abi_tag__ ("cxx11")))
> iterator
> erase(const_iterator __first, const_iterator __last)
> { return _M_t.erase(__first, __last); }
># 629 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> void
> clear() noexcept
> { _M_t.clear(); }
># 643 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> size_type
> count(const key_type& __x) const
> { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
># 661 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> iterator
> find(const key_type& __x)
> { return _M_t.find(__x); }
>
> const_iterator
> find(const key_type& __x) const
> { return _M_t.find(__x); }
># 682 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> iterator
> lower_bound(const key_type& __x)
> { return _M_t.lower_bound(__x); }
>
> const_iterator
> lower_bound(const key_type& __x) const
> { return _M_t.lower_bound(__x); }
># 698 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> iterator
> upper_bound(const key_type& __x)
> { return _M_t.upper_bound(__x); }
>
> const_iterator
> upper_bound(const key_type& __x) const
> { return _M_t.upper_bound(__x); }
># 723 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> std::pair<iterator, iterator>
> equal_range(const key_type& __x)
> { return _M_t.equal_range(__x); }
>
> std::pair<const_iterator, const_iterator>
> equal_range(const key_type& __x) const
> { return _M_t.equal_range(__x); }
>
>
> template<typename _K1, typename _C1, typename _A1>
> friend bool
> operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
>
> template<typename _K1, typename _C1, typename _A1>
> friend bool
> operator<(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
> };
># 752 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> template<typename _Key, typename _Compare, typename _Alloc>
> inline bool
> operator==(const set<_Key, _Compare, _Alloc>& __x,
> const set<_Key, _Compare, _Alloc>& __y)
> { return __x._M_t == __y._M_t; }
># 769 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
> template<typename _Key, typename _Compare, typename _Alloc>
> inline bool
> operator<(const set<_Key, _Compare, _Alloc>& __x,
> const set<_Key, _Compare, _Alloc>& __y)
> { return __x._M_t < __y._M_t; }
>
>
> template<typename _Key, typename _Compare, typename _Alloc>
> inline bool
> operator!=(const set<_Key, _Compare, _Alloc>& __x,
> const set<_Key, _Compare, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Key, typename _Compare, typename _Alloc>
> inline bool
> operator>(const set<_Key, _Compare, _Alloc>& __x,
> const set<_Key, _Compare, _Alloc>& __y)
> { return __y < __x; }
>
>
> template<typename _Key, typename _Compare, typename _Alloc>
> inline bool
> operator<=(const set<_Key, _Compare, _Alloc>& __x,
> const set<_Key, _Compare, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Key, typename _Compare, typename _Alloc>
> inline bool
> operator>=(const set<_Key, _Compare, _Alloc>& __x,
> const set<_Key, _Compare, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Key, typename _Compare, typename _Alloc>
> inline void
> swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
> { __x.swap(__y); }
>
>
>}
># 62 "/usr/include/c++/4.8.2/set" 2 3
># 1 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 1 3
># 64 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 90 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> template <typename _Key, typename _Compare = std::less<_Key>,
> typename _Alloc = std::allocator<_Key> >
> class multiset
> {
>
> typedef typename _Alloc::value_type _Alloc_value_type;
> 
> 
>
> 
>
> public:
>
> typedef _Key key_type;
> typedef _Key value_type;
> typedef _Compare key_compare;
> typedef _Compare value_compare;
> typedef _Alloc allocator_type;
>
> private:
>
> typedef typename _Alloc::template rebind<_Key>::other _Key_alloc_type;
>
> typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
> key_compare, _Key_alloc_type> _Rep_type;
>
> _Rep_type _M_t;
>
> public:
> typedef typename _Key_alloc_type::pointer pointer;
> typedef typename _Key_alloc_type::const_pointer const_pointer;
> typedef typename _Key_alloc_type::reference reference;
> typedef typename _Key_alloc_type::const_reference const_reference;
>
>
>
> typedef typename _Rep_type::const_iterator iterator;
> typedef typename _Rep_type::const_iterator const_iterator;
> typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
> typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
> typedef typename _Rep_type::size_type size_type;
> typedef typename _Rep_type::difference_type difference_type;
>
>
>
>
>
> multiset()
> : _M_t() { }
>
>
>
>
>
>
> explicit
> multiset(const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Key_alloc_type(__a)) { }
># 159 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> template<typename _InputIterator>
> multiset(_InputIterator __first, _InputIterator __last)
> : _M_t()
> { _M_t._M_insert_equal(__first, __last); }
># 175 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> template<typename _InputIterator>
> multiset(_InputIterator __first, _InputIterator __last,
> const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Key_alloc_type(__a))
> { _M_t._M_insert_equal(__first, __last); }
># 189 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> multiset(const multiset& __x)
> : _M_t(__x._M_t) { }
># 200 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> multiset(multiset&& __x)
> noexcept(is_nothrow_copy_constructible<_Compare>::value)
> : _M_t(std::move(__x._M_t)) { }
># 214 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> multiset(initializer_list<value_type> __l,
> const _Compare& __comp = _Compare(),
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, _Key_alloc_type(__a))
> { _M_t._M_insert_equal(__l.begin(), __l.end()); }
># 228 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> multiset&
> operator=(const multiset& __x)
> {
> _M_t = __x._M_t;
> return *this;
> }
># 244 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> multiset&
> operator=(multiset&& __x)
> {
>
>
> this->clear();
> this->swap(__x);
> return *this;
> }
># 265 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> multiset&
> operator=(initializer_list<value_type> __l)
> {
> this->clear();
> this->insert(__l.begin(), __l.end());
> return *this;
> }
>
>
>
>
>
> key_compare
> key_comp() const
> { return _M_t.key_comp(); }
>
> value_compare
> value_comp() const
> { return _M_t.key_comp(); }
>
> allocator_type
> get_allocator() const noexcept
> { return allocator_type(_M_t.get_allocator()); }
>
>
>
>
>
>
> iterator
> begin() const noexcept
> { return _M_t.begin(); }
>
>
>
>
>
>
> iterator
> end() const noexcept
> { return _M_t.end(); }
>
>
>
>
>
>
> reverse_iterator
> rbegin() const noexcept
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> reverse_iterator
> rend() const noexcept
> { return _M_t.rend(); }
>
>
>
>
>
>
>
> iterator
> cbegin() const noexcept
> { return _M_t.begin(); }
>
>
>
>
>
>
> iterator
> cend() const noexcept
> { return _M_t.end(); }
>
>
>
>
>
>
> reverse_iterator
> crbegin() const noexcept
> { return _M_t.rbegin(); }
>
>
>
>
>
>
> reverse_iterator
> crend() const noexcept
> { return _M_t.rend(); }
>
>
>
> bool
> empty() const noexcept
> { return _M_t.empty(); }
>
>
> size_type
> size() const noexcept
> { return _M_t.size(); }
>
>
> size_type
> max_size() const noexcept
> { return _M_t.max_size(); }
># 389 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> void
> swap(multiset& __x)
> { _M_t.swap(__x._M_t); }
># 407 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> template<typename... _Args>
> iterator
> emplace(_Args&&... __args)
> { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
># 433 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> template<typename... _Args>
> iterator
> emplace_hint(const_iterator __pos, _Args&&... __args)
> {
> return _M_t._M_emplace_hint_equal(__pos,
> std::forward<_Args>(__args)...);
> }
># 453 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> iterator
> insert(const value_type& __x)
> { return _M_t._M_insert_equal(__x); }
>
>
> iterator
> insert(value_type&& __x)
> { return _M_t._M_insert_equal(std::move(__x)); }
># 483 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> iterator
> insert(const_iterator __position, const value_type& __x)
> { return _M_t._M_insert_equal_(__position, __x); }
>
>
> iterator
> insert(const_iterator __position, value_type&& __x)
> { return _M_t._M_insert_equal_(__position, std::move(__x)); }
># 501 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> template<typename _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_t._M_insert_equal(__first, __last); }
># 514 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> void
> insert(initializer_list<value_type> __l)
> { this->insert(__l.begin(), __l.end()); }
># 535 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> __attribute ((__abi_tag__ ("cxx11")))
> iterator
> erase(const_iterator __position)
> { return _M_t.erase(__position); }
># 566 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> size_type
> erase(const key_type& __x)
> { return _M_t.erase(__x); }
># 587 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> __attribute ((__abi_tag__ ("cxx11")))
> iterator
> erase(const_iterator __first, const_iterator __last)
> { return _M_t.erase(__first, __last); }
># 615 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> void
> clear() noexcept
> { _M_t.clear(); }
># 626 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> size_type
> count(const key_type& __x) const
> { return _M_t.count(__x); }
># 644 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> iterator
> find(const key_type& __x)
> { return _M_t.find(__x); }
>
> const_iterator
> find(const key_type& __x) const
> { return _M_t.find(__x); }
># 665 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> iterator
> lower_bound(const key_type& __x)
> { return _M_t.lower_bound(__x); }
>
> const_iterator
> lower_bound(const key_type& __x) const
> { return _M_t.lower_bound(__x); }
># 681 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> iterator
> upper_bound(const key_type& __x)
> { return _M_t.upper_bound(__x); }
>
> const_iterator
> upper_bound(const key_type& __x) const
> { return _M_t.upper_bound(__x); }
># 706 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> std::pair<iterator, iterator>
> equal_range(const key_type& __x)
> { return _M_t.equal_range(__x); }
>
> std::pair<const_iterator, const_iterator>
> equal_range(const key_type& __x) const
> { return _M_t.equal_range(__x); }
>
>
> template<typename _K1, typename _C1, typename _A1>
> friend bool
> operator==(const multiset<_K1, _C1, _A1>&,
> const multiset<_K1, _C1, _A1>&);
>
> template<typename _K1, typename _C1, typename _A1>
> friend bool
> operator< (const multiset<_K1, _C1, _A1>&,
> const multiset<_K1, _C1, _A1>&);
> };
># 737 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> template<typename _Key, typename _Compare, typename _Alloc>
> inline bool
> operator==(const multiset<_Key, _Compare, _Alloc>& __x,
> const multiset<_Key, _Compare, _Alloc>& __y)
> { return __x._M_t == __y._M_t; }
># 754 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
> template<typename _Key, typename _Compare, typename _Alloc>
> inline bool
> operator<(const multiset<_Key, _Compare, _Alloc>& __x,
> const multiset<_Key, _Compare, _Alloc>& __y)
> { return __x._M_t < __y._M_t; }
>
>
> template<typename _Key, typename _Compare, typename _Alloc>
> inline bool
> operator!=(const multiset<_Key, _Compare, _Alloc>& __x,
> const multiset<_Key, _Compare, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Key, typename _Compare, typename _Alloc>
> inline bool
> operator>(const multiset<_Key,_Compare,_Alloc>& __x,
> const multiset<_Key,_Compare,_Alloc>& __y)
> { return __y < __x; }
>
>
> template<typename _Key, typename _Compare, typename _Alloc>
> inline bool
> operator<=(const multiset<_Key, _Compare, _Alloc>& __x,
> const multiset<_Key, _Compare, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Key, typename _Compare, typename _Alloc>
> inline bool
> operator>=(const multiset<_Key, _Compare, _Alloc>& __x,
> const multiset<_Key, _Compare, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Key, typename _Compare, typename _Alloc>
> inline void
> swap(multiset<_Key, _Compare, _Alloc>& __x,
> multiset<_Key, _Compare, _Alloc>& __y)
> { __x.swap(__y); }
>
>
>}
># 63 "/usr/include/c++/4.8.2/set" 2 3
># 96 "/usr/include/boost/detail/container_fwd.hpp" 2 3 4
># 1 "/usr/include/c++/4.8.2/bitset" 1 3 4
># 45 "/usr/include/c++/4.8.2/bitset" 3 4
> 
># 46 "/usr/include/c++/4.8.2/bitset" 3
># 60 "/usr/include/c++/4.8.2/bitset" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>
> template<size_t _Nw>
> struct _Base_bitset
> {
> typedef unsigned long _WordT;
>
>
> _WordT _M_w[_Nw];
>
> constexpr _Base_bitset() noexcept
> : _M_w() { }
>
>
> constexpr _Base_bitset(unsigned long long __val) noexcept
> : _M_w{ _WordT(__val)
>
>
>
> } { }
>
>
>
>
>
>
> static constexpr size_t
> _S_whichword(size_t __pos) noexcept
> { return __pos / (8 * 8); }
>
> static constexpr size_t
> _S_whichbyte(size_t __pos) noexcept
> { return (__pos % (8 * 8)) / 8; }
>
> static constexpr size_t
> _S_whichbit(size_t __pos) noexcept
> { return __pos % (8 * 8); }
>
> static constexpr _WordT
> _S_maskbit(size_t __pos) noexcept
> { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
>
> _WordT&
> _M_getword(size_t __pos) noexcept
> { return _M_w[_S_whichword(__pos)]; }
>
> constexpr _WordT
> _M_getword(size_t __pos) const noexcept
> { return _M_w[_S_whichword(__pos)]; }
>
>
> const _WordT*
> _M_getdata() const noexcept
> { return _M_w; }
>
>
> _WordT&
> _M_hiword() noexcept
> { return _M_w[_Nw - 1]; }
>
> constexpr _WordT
> _M_hiword() const noexcept
> { return _M_w[_Nw - 1]; }
>
> void
> _M_do_and(const _Base_bitset<_Nw>& __x) noexcept
> {
> for (size_t __i = 0; __i < _Nw; __i++)
> _M_w[__i] &= __x._M_w[__i];
> }
>
> void
> _M_do_or(const _Base_bitset<_Nw>& __x) noexcept
> {
> for (size_t __i = 0; __i < _Nw; __i++)
> _M_w[__i] |= __x._M_w[__i];
> }
>
> void
> _M_do_xor(const _Base_bitset<_Nw>& __x) noexcept
> {
> for (size_t __i = 0; __i < _Nw; __i++)
> _M_w[__i] ^= __x._M_w[__i];
> }
>
> void
> _M_do_left_shift(size_t __shift) noexcept;
>
> void
> _M_do_right_shift(size_t __shift) noexcept;
>
> void
> _M_do_flip() noexcept
> {
> for (size_t __i = 0; __i < _Nw; __i++)
> _M_w[__i] = ~_M_w[__i];
> }
>
> void
> _M_do_set() noexcept
> {
> for (size_t __i = 0; __i < _Nw; __i++)
> _M_w[__i] = ~static_cast<_WordT>(0);
> }
>
> void
> _M_do_reset() noexcept
> { __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT)); }
>
> bool
> _M_is_equal(const _Base_bitset<_Nw>& __x) const noexcept
> {
> for (size_t __i = 0; __i < _Nw; ++__i)
> if (_M_w[__i] != __x._M_w[__i])
> return false;
> return true;
> }
>
> template<size_t _Nb>
> bool
> _M_are_all() const noexcept
> {
> for (size_t __i = 0; __i < _Nw - 1; __i++)
> if (_M_w[__i] != ~static_cast<_WordT>(0))
> return false;
> return _M_hiword() == (~static_cast<_WordT>(0)
> >> (_Nw * (8 * 8)
> - _Nb));
> }
>
> bool
> _M_is_any() const noexcept
> {
> for (size_t __i = 0; __i < _Nw; __i++)
> if (_M_w[__i] != static_cast<_WordT>(0))
> return true;
> return false;
> }
>
> size_t
> _M_do_count() const noexcept
> {
> size_t __result = 0;
> for (size_t __i = 0; __i < _Nw; __i++)
> __result += __builtin_popcountl(_M_w[__i]);
> return __result;
> }
>
> unsigned long
> _M_do_to_ulong() const;
>
>
> unsigned long long
> _M_do_to_ullong() const;
>
>
>
> size_t
> _M_do_find_first(size_t) const noexcept;
>
>
> size_t
> _M_do_find_next(size_t, size_t) const noexcept;
> };
>
>
> template<size_t _Nw>
> void
> _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) noexcept
> {
> if (__builtin_expect(__shift != 0, 1))
> {
> const size_t __wshift = __shift / (8 * 8);
> const size_t __offset = __shift % (8 * 8);
>
> if (__offset == 0)
> for (size_t __n = _Nw - 1; __n >= __wshift; --__n)
> _M_w[__n] = _M_w[__n - __wshift];
> else
> {
> const size_t __sub_offset = ((8 * 8)
> - __offset);
> for (size_t __n = _Nw - 1; __n > __wshift; --__n)
> _M_w[__n] = ((_M_w[__n - __wshift] << __offset)
> | (_M_w[__n - __wshift - 1] >> __sub_offset));
> _M_w[__wshift] = _M_w[0] << __offset;
> }
>
> std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));
> }
> }
>
> template<size_t _Nw>
> void
> _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) noexcept
> {
> if (__builtin_expect(__shift != 0, 1))
> {
> const size_t __wshift = __shift / (8 * 8);
> const size_t __offset = __shift % (8 * 8);
> const size_t __limit = _Nw - __wshift - 1;
>
> if (__offset == 0)
> for (size_t __n = 0; __n <= __limit; ++__n)
> _M_w[__n] = _M_w[__n + __wshift];
> else
> {
> const size_t __sub_offset = ((8 * 8)
> - __offset);
> for (size_t __n = 0; __n < __limit; ++__n)
> _M_w[__n] = ((_M_w[__n + __wshift] >> __offset)
> | (_M_w[__n + __wshift + 1] << __sub_offset));
> _M_w[__limit] = _M_w[_Nw-1] >> __offset;
> }
>
> std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
> }
> }
>
> template<size_t _Nw>
> unsigned long
> _Base_bitset<_Nw>::_M_do_to_ulong() const
> {
> for (size_t __i = 1; __i < _Nw; ++__i)
> if (_M_w[__i])
> __throw_overflow_error(("_Base_bitset::_M_do_to_ulong"));
> return _M_w[0];
> }
>
>
> template<size_t _Nw>
> unsigned long long
> _Base_bitset<_Nw>::_M_do_to_ullong() const
> {
> const bool __dw = sizeof(unsigned long long) > sizeof(unsigned long);
> for (size_t __i = 1 + __dw; __i < _Nw; ++__i)
> if (_M_w[__i])
> __throw_overflow_error(("_Base_bitset::_M_do_to_ullong"));
>
> if (__dw)
> return _M_w[0] + (static_cast<unsigned long long>(_M_w[1])
> << (8 * 8));
> return _M_w[0];
> }
>
>
> template<size_t _Nw>
> size_t
> _Base_bitset<_Nw>::
> _M_do_find_first(size_t __not_found) const noexcept
> {
> for (size_t __i = 0; __i < _Nw; __i++)
> {
> _WordT __thisword = _M_w[__i];
> if (__thisword != static_cast<_WordT>(0))
> return (__i * (8 * 8)
> + __builtin_ctzl(__thisword));
> }
>
> return __not_found;
> }
>
> template<size_t _Nw>
> size_t
> _Base_bitset<_Nw>::
> _M_do_find_next(size_t __prev, size_t __not_found) const noexcept
> {
>
> ++__prev;
>
>
> if (__prev >= _Nw * (8 * 8))
> return __not_found;
>
>
> size_t __i = _S_whichword(__prev);
> _WordT __thisword = _M_w[__i];
>
>
> __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);
>
> if (__thisword != static_cast<_WordT>(0))
> return (__i * (8 * 8)
> + __builtin_ctzl(__thisword));
>
>
> __i++;
> for (; __i < _Nw; __i++)
> {
> __thisword = _M_w[__i];
> if (__thisword != static_cast<_WordT>(0))
> return (__i * (8 * 8)
> + __builtin_ctzl(__thisword));
> }
>
> return __not_found;
> }
>
>
>
>
>
>
> template<>
> struct _Base_bitset<1>
> {
> typedef unsigned long _WordT;
> _WordT _M_w;
>
> constexpr _Base_bitset() noexcept
> : _M_w(0)
> { }
>
>
> constexpr _Base_bitset(unsigned long long __val) noexcept
>
>
>
> : _M_w(__val)
> { }
>
> static constexpr size_t
> _S_whichword(size_t __pos) noexcept
> { return __pos / (8 * 8); }
>
> static constexpr size_t
> _S_whichbyte(size_t __pos) noexcept
> { return (__pos % (8 * 8)) / 8; }
>
> static constexpr size_t
> _S_whichbit(size_t __pos) noexcept
> { return __pos % (8 * 8); }
>
> static constexpr _WordT
> _S_maskbit(size_t __pos) noexcept
> { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
>
> _WordT&
> _M_getword(size_t) noexcept
> { return _M_w; }
>
> constexpr _WordT
> _M_getword(size_t) const noexcept
> { return _M_w; }
>
>
> const _WordT*
> _M_getdata() const noexcept
> { return &_M_w; }
>
>
> _WordT&
> _M_hiword() noexcept
> { return _M_w; }
>
> constexpr _WordT
> _M_hiword() const noexcept
> { return _M_w; }
>
> void
> _M_do_and(const _Base_bitset<1>& __x) noexcept
> { _M_w &= __x._M_w; }
>
> void
> _M_do_or(const _Base_bitset<1>& __x) noexcept
> { _M_w |= __x._M_w; }
>
> void
> _M_do_xor(const _Base_bitset<1>& __x) noexcept
> { _M_w ^= __x._M_w; }
>
> void
> _M_do_left_shift(size_t __shift) noexcept
> { _M_w <<= __shift; }
>
> void
> _M_do_right_shift(size_t __shift) noexcept
> { _M_w >>= __shift; }
>
> void
> _M_do_flip() noexcept
> { _M_w = ~_M_w; }
>
> void
> _M_do_set() noexcept
> { _M_w = ~static_cast<_WordT>(0); }
>
> void
> _M_do_reset() noexcept
> { _M_w = 0; }
>
> bool
> _M_is_equal(const _Base_bitset<1>& __x) const noexcept
> { return _M_w == __x._M_w; }
>
> template<size_t _Nb>
> bool
> _M_are_all() const noexcept
> { return _M_w == (~static_cast<_WordT>(0)
> >> ((8 * 8) - _Nb)); }
>
> bool
> _M_is_any() const noexcept
> { return _M_w != 0; }
>
> size_t
> _M_do_count() const noexcept
> { return __builtin_popcountl(_M_w); }
>
> unsigned long
> _M_do_to_ulong() const noexcept
> { return _M_w; }
>
>
> unsigned long long
> _M_do_to_ullong() const noexcept
> { return _M_w; }
>
>
> size_t
> _M_do_find_first(size_t __not_found) const noexcept
> {
> if (_M_w != 0)
> return __builtin_ctzl(_M_w);
> else
> return __not_found;
> }
>
>
> size_t
> _M_do_find_next(size_t __prev, size_t __not_found) const
> noexcept
> {
> ++__prev;
> if (__prev >= ((size_t) (8 * 8)))
> return __not_found;
>
> _WordT __x = _M_w >> __prev;
> if (__x != 0)
> return __builtin_ctzl(__x) + __prev;
> else
> return __not_found;
> }
> };
>
>
>
>
>
>
> template<>
> struct _Base_bitset<0>
> {
> typedef unsigned long _WordT;
>
> constexpr _Base_bitset() noexcept
> { }
>
>
> constexpr _Base_bitset(unsigned long long) noexcept
>
>
>
> { }
>
> static constexpr size_t
> _S_whichword(size_t __pos) noexcept
> { return __pos / (8 * 8); }
>
> static constexpr size_t
> _S_whichbyte(size_t __pos) noexcept
> { return (__pos % (8 * 8)) / 8; }
>
> static constexpr size_t
> _S_whichbit(size_t __pos) noexcept
> { return __pos % (8 * 8); }
>
> static constexpr _WordT
> _S_maskbit(size_t __pos) noexcept
> { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
># 556 "/usr/include/c++/4.8.2/bitset" 3
> _WordT&
> _M_getword(size_t) noexcept
> {
> __throw_out_of_range(("_Base_bitset::_M_getword"));
> return *new _WordT;
> }
>
> constexpr _WordT
> _M_getword(size_t __pos) const noexcept
> { return 0; }
>
> constexpr _WordT
> _M_hiword() const noexcept
> { return 0; }
>
> void
> _M_do_and(const _Base_bitset<0>&) noexcept
> { }
>
> void
> _M_do_or(const _Base_bitset<0>&) noexcept
> { }
>
> void
> _M_do_xor(const _Base_bitset<0>&) noexcept
> { }
>
> void
> _M_do_left_shift(size_t) noexcept
> { }
>
> void
> _M_do_right_shift(size_t) noexcept
> { }
>
> void
> _M_do_flip() noexcept
> { }
>
> void
> _M_do_set() noexcept
> { }
>
> void
> _M_do_reset() noexcept
> { }
>
>
>
>
> bool
> _M_is_equal(const _Base_bitset<0>&) const noexcept
> { return true; }
>
> template<size_t _Nb>
> bool
> _M_are_all() const noexcept
> { return true; }
>
> bool
> _M_is_any() const noexcept
> { return false; }
>
> size_t
> _M_do_count() const noexcept
> { return 0; }
>
> unsigned long
> _M_do_to_ulong() const noexcept
> { return 0; }
>
>
> unsigned long long
> _M_do_to_ullong() const noexcept
> { return 0; }
>
>
>
>
> size_t
> _M_do_find_first(size_t) const noexcept
> { return 0; }
>
> size_t
> _M_do_find_next(size_t, size_t) const noexcept
> { return 0; }
> };
>
>
>
> template<size_t _Extrabits>
> struct _Sanitize
> {
> typedef unsigned long _WordT;
>
> static void
> _S_do_sanitize(_WordT& __val) noexcept
> { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); }
> };
>
> template<>
> struct _Sanitize<0>
> {
> typedef unsigned long _WordT;
>
> static void
> _S_do_sanitize(_WordT) noexcept { }
> };
>
>
> template<size_t _Nb, bool = _Nb < (8 * 8)>
> struct _Sanitize_val
> {
> static constexpr unsigned long long
> _S_do_sanitize_val(unsigned long long __val)
> { return __val; }
> };
>
> template<size_t _Nb>
> struct _Sanitize_val<_Nb, true>
> {
> static constexpr unsigned long long
> _S_do_sanitize_val(unsigned long long __val)
> { return __val & ~((~static_cast<unsigned long long>(0)) << _Nb); }
> };
># 747 "/usr/include/c++/4.8.2/bitset" 3
> template<size_t _Nb>
> class bitset
> : private _Base_bitset<((_Nb) / (8 * 8) + ((_Nb) % (8 * 8) == 0 ? 0 : 1))>
> {
> private:
> typedef _Base_bitset<((_Nb) / (8 * 8) + ((_Nb) % (8 * 8) == 0 ? 0 : 1))> _Base;
> typedef unsigned long _WordT;
>
> void
> _M_do_sanitize() noexcept
> {
> typedef _Sanitize<_Nb % (8 * 8)> __sanitize_type;
> __sanitize_type::_S_do_sanitize(this->_M_hiword());
> }
>
>
> template<typename> friend struct hash;
>
>
> public:
># 779 "/usr/include/c++/4.8.2/bitset" 3
> class reference
> {
> friend class bitset;
>
> _WordT* _M_wp;
> size_t _M_bpos;
>
>
> reference();
>
> public:
> reference(bitset& __b, size_t __pos) noexcept
> {
> _M_wp = &__b._M_getword(__pos);
> _M_bpos = _Base::_S_whichbit(__pos);
> }
>
> ~reference() noexcept
> { }
>
>
> reference&
> operator=(bool __x) noexcept
> {
> if (__x)
> *_M_wp |= _Base::_S_maskbit(_M_bpos);
> else
> *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
> return *this;
> }
>
>
> reference&
> operator=(const reference& __j) noexcept
> {
> if ((*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos)))
> *_M_wp |= _Base::_S_maskbit(_M_bpos);
> else
> *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
> return *this;
> }
>
>
> bool
> operator~() const noexcept
> { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; }
>
>
> operator bool() const noexcept
> { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; }
>
>
> reference&
> flip() noexcept
> {
> *_M_wp ^= _Base::_S_maskbit(_M_bpos);
> return *this;
> }
> };
> friend class reference;
>
>
>
> constexpr bitset() noexcept
> { }
>
>
>
> constexpr bitset(unsigned long long __val) noexcept
> : _Base(_Sanitize_val<_Nb>::_S_do_sanitize_val(__val)) { }
># 864 "/usr/include/c++/4.8.2/bitset" 3
> template<class _CharT, class _Traits, class _Alloc>
> explicit
> bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
> size_t __position = 0)
> : _Base()
> {
> if (__position > __s.size())
> __throw_out_of_range(("bitset::bitset initial position " "not valid")
> );
> _M_copy_from_string(__s, __position,
> std::basic_string<_CharT, _Traits, _Alloc>::npos,
> _CharT('0'), _CharT('1'));
> }
># 888 "/usr/include/c++/4.8.2/bitset" 3
> template<class _CharT, class _Traits, class _Alloc>
> bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
> size_t __position, size_t __n)
> : _Base()
> {
> if (__position > __s.size())
> __throw_out_of_range(("bitset::bitset initial position " "not valid")
> );
> _M_copy_from_string(__s, __position, __n, _CharT('0'), _CharT('1'));
> }
>
>
>
> template<class _CharT, class _Traits, class _Alloc>
> bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
> size_t __position, size_t __n,
> _CharT __zero, _CharT __one = _CharT('1'))
> : _Base()
> {
> if (__position > __s.size())
> __throw_out_of_range(("bitset::bitset initial position " "not valid")
> );
> _M_copy_from_string(__s, __position, __n, __zero, __one);
> }
># 923 "/usr/include/c++/4.8.2/bitset" 3
> template<typename _CharT>
> explicit
> bitset(const _CharT* __str,
> typename std::basic_string<_CharT>::size_type __n
> = std::basic_string<_CharT>::npos,
> _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
> : _Base()
> {
> if (!__str)
> __throw_logic_error(("bitset::bitset(const _CharT*, ...)"));
>
> if (__n == std::basic_string<_CharT>::npos)
> __n = std::char_traits<_CharT>::length(__str);
> _M_copy_from_ptr<_CharT, std::char_traits<_CharT>>(__str, __n, 0,
> __n, __zero,
> __one);
> }
># 950 "/usr/include/c++/4.8.2/bitset" 3
> bitset<_Nb>&
> operator&=(const bitset<_Nb>& __rhs) noexcept
> {
> this->_M_do_and(__rhs);
> return *this;
> }
>
> bitset<_Nb>&
> operator|=(const bitset<_Nb>& __rhs) noexcept
> {
> this->_M_do_or(__rhs);
> return *this;
> }
>
> bitset<_Nb>&
> operator^=(const bitset<_Nb>& __rhs) noexcept
> {
> this->_M_do_xor(__rhs);
> return *this;
> }
># 979 "/usr/include/c++/4.8.2/bitset" 3
> bitset<_Nb>&
> operator<<=(size_t __position) noexcept
> {
> if (__builtin_expect(__position < _Nb, 1))
> {
> this->_M_do_left_shift(__position);
> this->_M_do_sanitize();
> }
> else
> this->_M_do_reset();
> return *this;
> }
>
> bitset<_Nb>&
> operator>>=(size_t __position) noexcept
> {
> if (__builtin_expect(__position < _Nb, 1))
> {
> this->_M_do_right_shift(__position);
> this->_M_do_sanitize();
> }
> else
> this->_M_do_reset();
> return *this;
> }
># 1012 "/usr/include/c++/4.8.2/bitset" 3
> bitset<_Nb>&
> _Unchecked_set(size_t __pos) noexcept
> {
> this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
> return *this;
> }
>
> bitset<_Nb>&
> _Unchecked_set(size_t __pos, int __val) noexcept
> {
> if (__val)
> this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
> else
> this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
> return *this;
> }
>
> bitset<_Nb>&
> _Unchecked_reset(size_t __pos) noexcept
> {
> this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
> return *this;
> }
>
> bitset<_Nb>&
> _Unchecked_flip(size_t __pos) noexcept
> {
> this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos);
> return *this;
> }
>
> constexpr bool
> _Unchecked_test(size_t __pos) const noexcept
> { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
> != static_cast<_WordT>(0)); }
>
>
>
>
>
>
> bitset<_Nb>&
> set() noexcept
> {
> this->_M_do_set();
> this->_M_do_sanitize();
> return *this;
> }
>
>
>
>
>
>
>
> bitset<_Nb>&
> set(size_t __position, bool __val = true)
> {
> if (__position >= _Nb)
> __throw_out_of_range(("bitset::set"));
> return _Unchecked_set(__position, __val);
> }
>
>
>
>
> bitset<_Nb>&
> reset() noexcept
> {
> this->_M_do_reset();
> return *this;
> }
># 1092 "/usr/include/c++/4.8.2/bitset" 3
> bitset<_Nb>&
> reset(size_t __position)
> {
> if (__position >= _Nb)
> __throw_out_of_range(("bitset::reset"));
> return _Unchecked_reset(__position);
> }
>
>
>
>
> bitset<_Nb>&
> flip() noexcept
> {
> this->_M_do_flip();
> this->_M_do_sanitize();
> return *this;
> }
>
>
>
>
>
>
> bitset<_Nb>&
> flip(size_t __position)
> {
> if (__position >= _Nb)
> __throw_out_of_range(("bitset::flip"));
> return _Unchecked_flip(__position);
> }
>
>
> bitset<_Nb>
> operator~() const noexcept
> { return bitset<_Nb>(*this).flip(); }
># 1144 "/usr/include/c++/4.8.2/bitset" 3
> reference
> operator[](size_t __position)
> { return reference(*this, __position); }
>
> constexpr bool
> operator[](size_t __position) const
> { return _Unchecked_test(__position); }
># 1159 "/usr/include/c++/4.8.2/bitset" 3
> unsigned long
> to_ulong() const
> { return this->_M_do_to_ulong(); }
>
>
> unsigned long long
> to_ullong() const
> { return this->_M_do_to_ullong(); }
># 1177 "/usr/include/c++/4.8.2/bitset" 3
> template<class _CharT, class _Traits, class _Alloc>
> std::basic_string<_CharT, _Traits, _Alloc>
> to_string() const
> {
> std::basic_string<_CharT, _Traits, _Alloc> __result;
> _M_copy_to_string(__result, _CharT('0'), _CharT('1'));
> return __result;
> }
>
>
>
> template<class _CharT, class _Traits, class _Alloc>
> std::basic_string<_CharT, _Traits, _Alloc>
> to_string(_CharT __zero, _CharT __one = _CharT('1')) const
> {
> std::basic_string<_CharT, _Traits, _Alloc> __result;
> _M_copy_to_string(__result, __zero, __one);
> return __result;
> }
>
>
>
> template<class _CharT, class _Traits>
> std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
> to_string() const
> { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
>
>
>
> template<class _CharT, class _Traits>
> std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
> to_string(_CharT __zero, _CharT __one = _CharT('1')) const
> { return to_string<_CharT, _Traits,
> std::allocator<_CharT> >(__zero, __one); }
>
> template<class _CharT>
> std::basic_string<_CharT, std::char_traits<_CharT>,
> std::allocator<_CharT> >
> to_string() const
> {
> return to_string<_CharT, std::char_traits<_CharT>,
> std::allocator<_CharT> >();
> }
>
> template<class _CharT>
> std::basic_string<_CharT, std::char_traits<_CharT>,
> std::allocator<_CharT> >
> to_string(_CharT __zero, _CharT __one = _CharT('1')) const
> {
> return to_string<_CharT, std::char_traits<_CharT>,
> std::allocator<_CharT> >(__zero, __one);
> }
>
> std::basic_string<char, std::char_traits<char>, std::allocator<char> >
> to_string() const
> {
> return to_string<char, std::char_traits<char>,
> std::allocator<char> >();
> }
>
> std::basic_string<char, std::char_traits<char>, std::allocator<char> >
> to_string(char __zero, char __one = '1') const
> {
> return to_string<char, std::char_traits<char>,
> std::allocator<char> >(__zero, __one);
> }
>
>
> template<class _CharT, class _Traits>
> void
> _M_copy_from_ptr(const _CharT*, size_t, size_t, size_t,
> _CharT, _CharT);
>
> template<class _CharT, class _Traits, class _Alloc>
> void
> _M_copy_from_string(const std::basic_string<_CharT,
> _Traits, _Alloc>& __s, size_t __pos, size_t __n,
> _CharT __zero, _CharT __one)
> { _M_copy_from_ptr<_CharT, _Traits>(__s.data(), __s.size(), __pos, __n,
> __zero, __one); }
>
> template<class _CharT, class _Traits, class _Alloc>
> void
> _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>&,
> _CharT, _CharT) const;
>
>
> template<class _CharT, class _Traits, class _Alloc>
> void
> _M_copy_from_string(const std::basic_string<_CharT,
> _Traits, _Alloc>& __s, size_t __pos, size_t __n)
> { _M_copy_from_string(__s, __pos, __n, _CharT('0'), _CharT('1')); }
>
> template<class _CharT, class _Traits, class _Alloc>
> void
> _M_copy_to_string(std::basic_string<_CharT, _Traits,_Alloc>& __s) const
> { _M_copy_to_string(__s, _CharT('0'), _CharT('1')); }
>
>
> size_t
> count() const noexcept
> { return this->_M_do_count(); }
>
>
> constexpr size_t
> size() const noexcept
> { return _Nb; }
>
>
>
> bool
> operator==(const bitset<_Nb>& __rhs) const noexcept
> { return this->_M_is_equal(__rhs); }
>
> bool
> operator!=(const bitset<_Nb>& __rhs) const noexcept
> { return !this->_M_is_equal(__rhs); }
># 1302 "/usr/include/c++/4.8.2/bitset" 3
> bool
> test(size_t __position) const
> {
> if (__position >= _Nb)
> __throw_out_of_range(("bitset::test"));
> return _Unchecked_test(__position);
> }
>
>
>
>
>
>
>
> bool
> all() const noexcept
> { return this->template _M_are_all<_Nb>(); }
>
>
>
>
>
> bool
> any() const noexcept
> { return this->_M_is_any(); }
>
>
>
>
>
> bool
> none() const noexcept
> { return !this->_M_is_any(); }
>
>
>
> bitset<_Nb>
> operator<<(size_t __position) const noexcept
> { return bitset<_Nb>(*this) <<= __position; }
>
> bitset<_Nb>
> operator>>(size_t __position) const noexcept
> { return bitset<_Nb>(*this) >>= __position; }
># 1353 "/usr/include/c++/4.8.2/bitset" 3
> size_t
> _Find_first() const noexcept
> { return this->_M_do_find_first(_Nb); }
># 1364 "/usr/include/c++/4.8.2/bitset" 3
> size_t
> _Find_next(size_t __prev) const noexcept
> { return this->_M_do_find_next(__prev, _Nb); }
> };
>
>
> template<size_t _Nb>
> template<class _CharT, class _Traits>
> void
> bitset<_Nb>::
> _M_copy_from_ptr(const _CharT* __s, size_t __len,
> size_t __pos, size_t __n, _CharT __zero, _CharT __one)
> {
> reset();
> const size_t __nbits = std::min(_Nb, std::min(__n, size_t(__len - __pos)));
> for (size_t __i = __nbits; __i > 0; --__i)
> {
> const _CharT __c = __s[__pos + __nbits - __i];
> if (_Traits::eq(__c, __zero))
> ;
> else if (_Traits::eq(__c, __one))
> _Unchecked_set(__i - 1);
> else
> __throw_invalid_argument(("bitset::_M_copy_from_ptr"));
> }
> }
>
> template<size_t _Nb>
> template<class _CharT, class _Traits, class _Alloc>
> void
> bitset<_Nb>::
> _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>& __s,
> _CharT __zero, _CharT __one) const
> {
> __s.assign(_Nb, __zero);
> for (size_t __i = _Nb; __i > 0; --__i)
> if (_Unchecked_test(__i - 1))
> _Traits::assign(__s[_Nb - __i], __one);
> }
># 1414 "/usr/include/c++/4.8.2/bitset" 3
> template<size_t _Nb>
> inline bitset<_Nb>
> operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
> {
> bitset<_Nb> __result(__x);
> __result &= __y;
> return __result;
> }
>
> template<size_t _Nb>
> inline bitset<_Nb>
> operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
> {
> bitset<_Nb> __result(__x);
> __result |= __y;
> return __result;
> }
>
> template <size_t _Nb>
> inline bitset<_Nb>
> operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
> {
> bitset<_Nb> __result(__x);
> __result ^= __y;
> return __result;
> }
># 1451 "/usr/include/c++/4.8.2/bitset" 3
> template<class _CharT, class _Traits, size_t _Nb>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
> {
> typedef typename _Traits::char_type char_type;
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> std::basic_string<_CharT, _Traits> __tmp;
> __tmp.reserve(_Nb);
>
>
>
> const char_type __zero = __is.widen('0');
> const char_type __one = __is.widen('1');
>
> typename __ios_base::iostate __state = __ios_base::goodbit;
> typename __istream_type::sentry __sentry(__is);
> if (__sentry)
> {
> try
> {
> for (size_t __i = _Nb; __i > 0; --__i)
> {
> static typename _Traits::int_type __eof = _Traits::eof();
>
> typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc();
> if (_Traits::eq_int_type(__c1, __eof))
> {
> __state |= __ios_base::eofbit;
> break;
> }
> else
> {
> const char_type __c2 = _Traits::to_char_type(__c1);
> if (_Traits::eq(__c2, __zero))
> __tmp.push_back(__zero);
> else if (_Traits::eq(__c2, __one))
> __tmp.push_back(__one);
> else if (_Traits::
> eq_int_type(__is.rdbuf()->sputbackc(__c2),
> __eof))
> {
> __state |= __ios_base::failbit;
> break;
> }
> }
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __is._M_setstate(__ios_base::badbit);
> throw;
> }
> catch(...)
> { __is._M_setstate(__ios_base::badbit); }
> }
>
> if (__tmp.empty() && _Nb)
> __state |= __ios_base::failbit;
> else
> __x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb,
> __zero, __one);
> if (__state)
> __is.setstate(__state);
> return __is;
> }
>
> template <class _CharT, class _Traits, size_t _Nb>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const bitset<_Nb>& __x)
> {
> std::basic_string<_CharT, _Traits> __tmp;
>
>
>
> const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__os.getloc());
> __x._M_copy_to_string(__tmp, __ct.widen('0'), __ct.widen('1'));
> return __os << __tmp;
> }
>
>
>
>}
># 1545 "/usr/include/c++/4.8.2/bitset" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
> template<size_t _Nb>
> struct hash<std::bitset<_Nb>>
> : public __hash_base<size_t, std::bitset<_Nb>>
> {
> size_t
> operator()(const std::bitset<_Nb>& __b) const noexcept
> {
> const size_t __clength = (_Nb + 8 - 1) / 8;
> return std::_Hash_impl::hash(__b._M_getdata(), __clength);
> }
> };
>
> template<>
> struct hash<std::bitset<0>>
> : public __hash_base<size_t, std::bitset<0>>
> {
> size_t
> operator()(const std::bitset<0>&) const noexcept
> { return 0; }
> };
>
>
>}
># 97 "/usr/include/boost/detail/container_fwd.hpp" 2 3 4
># 18 "/usr/include/boost/functional/hash/extensions.hpp" 2 3 4
># 47 "/usr/include/boost/functional/hash/extensions.hpp" 3 4
>namespace boost
>{
> template <class A, class B>
> std::size_t hash_value(std::pair<A, B> const&);
> template <class T, class A>
> std::size_t hash_value(std::vector<T, A> const&);
> template <class T, class A>
> std::size_t hash_value(std::list<T, A> const& v);
> template <class T, class A>
> std::size_t hash_value(std::deque<T, A> const& v);
> template <class K, class C, class A>
> std::size_t hash_value(std::set<K, C, A> const& v);
> template <class K, class C, class A>
> std::size_t hash_value(std::multiset<K, C, A> const& v);
> template <class K, class T, class C, class A>
> std::size_t hash_value(std::map<K, T, C, A> const& v);
> template <class K, class T, class C, class A>
> std::size_t hash_value(std::multimap<K, T, C, A> const& v);
>
> template <class T>
> std::size_t hash_value(std::complex<T> const&);
>
> template <class A, class B>
> std::size_t hash_value(std::pair<A, B> const& v)
> {
> std::size_t seed = 0;
> boost::hash_combine(seed, v.first);
> boost::hash_combine(seed, v.second);
> return seed;
> }
>
> template <class T, class A>
> std::size_t hash_value(std::vector<T, A> const& v)
> {
> return boost::hash_range(v.begin(), v.end());
> }
>
> template <class T, class A>
> std::size_t hash_value(std::list<T, A> const& v)
> {
> return boost::hash_range(v.begin(), v.end());
> }
>
> template <class T, class A>
> std::size_t hash_value(std::deque<T, A> const& v)
> {
> return boost::hash_range(v.begin(), v.end());
> }
>
> template <class K, class C, class A>
> std::size_t hash_value(std::set<K, C, A> const& v)
> {
> return boost::hash_range(v.begin(), v.end());
> }
>
> template <class K, class C, class A>
> std::size_t hash_value(std::multiset<K, C, A> const& v)
> {
> return boost::hash_range(v.begin(), v.end());
> }
>
> template <class K, class T, class C, class A>
> std::size_t hash_value(std::map<K, T, C, A> const& v)
> {
> return boost::hash_range(v.begin(), v.end());
> }
>
> template <class K, class T, class C, class A>
> std::size_t hash_value(std::multimap<K, T, C, A> const& v)
> {
> return boost::hash_range(v.begin(), v.end());
> }
>
> template <class T>
> std::size_t hash_value(std::complex<T> const& v)
> {
> boost::hash<T> hasher;
> std::size_t seed = hasher(v.imag());
> seed ^= hasher(v.real()) + (seed<<6) + (seed>>2);
> return seed;
> }
>
>
> template <class T, std::size_t N>
> std::size_t hash_value(std::array<T, N> const& v)
> {
> return boost::hash_range(v.begin(), v.end());
> }
>
>
>
> namespace hash_detail {
> template <std::size_t I, typename T>
> inline typename boost::enable_if_c<(I == std::tuple_size<T>::value),
> void>::type
> hash_combine_tuple(std::size_t&, T const&)
> {
> }
>
> template <std::size_t I, typename T>
> inline typename boost::enable_if_c<(I < std::tuple_size<T>::value),
> void>::type
> hash_combine_tuple(std::size_t& seed, T const& v)
> {
> boost::hash_combine(seed, std::get(v));
> boost::hash_detail::hash_combine_tuple(seed, v);
> }
>
> template <typename T>
> inline std::size_t hash_tuple(T const& v)
> {
> std::size_t seed = 0;
> boost::hash_detail::hash_combine_tuple<0>(seed, v);
> return seed;
> }
> }
>
>
> template <typename... T>
> inline std::size_t hash_value(std::tuple<T...> const& v)
> {
> return boost::hash_detail::hash_tuple(v);
> }
># 195 "/usr/include/boost/functional/hash/extensions.hpp" 3 4
> template <typename T>
> inline std::size_t hash_value(std::shared_ptr<T> const& x) {
> return boost::hash_value(x.get());
> }
>
> template <typename T, typename Deleter>
> inline std::size_t hash_value(std::unique_ptr<T, Deleter> const& x) {
> return boost::hash_value(x.get());
> }
># 263 "/usr/include/boost/functional/hash/extensions.hpp" 3 4
> template <class T> struct hash
> : std::unary_function<T, std::size_t>
> {
>
> std::size_t operator()(T const& val) const
> {
> return hash_value(val);
> }
>
>
>
>
>
>
> };
># 377 "/usr/include/boost/functional/hash/extensions.hpp" 3 4
>}
># 530 "/usr/include/boost/functional/hash/hash.hpp" 2 3 4
># 7 "/usr/include/boost/functional/hash.hpp" 2 3 4
># 38 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4
># 46 "/usr/include/boost/thread/detail/thread.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 47 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost
>{
>
> namespace detail
> {
># 90 "/usr/include/boost/thread/detail/thread.hpp" 3 4
> template<typename F>
> class thread_data:
> public detail::thread_data_base
> {
> public:
> thread_data(thread_data const&) = delete; thread_data& operator=(thread_data const&) = delete;
>
> thread_data(F && f_):
> f(boost::forward<F>(f_))
> {}
># 115 "/usr/include/boost/thread/detail/thread.hpp" 3 4
> void run()
> {
> f();
> }
>
> private:
> F f;
> };
>
> template<typename F>
> class thread_data<boost::reference_wrapper<F> >:
> public detail::thread_data_base
> {
> private:
> F& f;
> public:
> thread_data(thread_data const&) = delete; thread_data& operator=(thread_data const&) = delete;
> thread_data(boost::reference_wrapper<F> f_):
> f(f_)
> {}
> void run()
> {
> f();
> }
> };
>
> template<typename F>
> class thread_data<const boost::reference_wrapper<F> >:
> public detail::thread_data_base
> {
> private:
> F& f;
> public:
> thread_data(thread_data const&) = delete; thread_data& operator=(thread_data const&) = delete;
> thread_data(const boost::reference_wrapper<F> f_):
> f(f_)
> {}
> void run()
> {
> f();
> }
> };
>
> }
>
> class __attribute__((__visibility__("default"))) thread
> {
> public:
> typedef thread_attributes attributes;
>
> thread(thread const&) = delete; thread& operator=(thread const&) = delete;
> private:
>
> struct dummy;
>
> void release_handle();
>
> detail::thread_data_ptr thread_info;
>
> private:
> bool start_thread_noexcept();
> bool start_thread_noexcept(const attributes& attr);
> public:
> void start_thread()
> {
> if (!start_thread_noexcept())
> {
> boost::throw_exception(thread_resource_error());
> }
> }
> void start_thread(const attributes& attr)
> {
> if (!start_thread_noexcept(attr))
> {
> boost::throw_exception(thread_resource_error());
> }
> }
>
> explicit thread(detail::thread_data_ptr data);
>
> detail::thread_data_ptr get_thread_info () const;
># 210 "/usr/include/boost/thread/detail/thread.hpp" 3 4
> template<typename F>
> static inline detail::thread_data_ptr make_thread_info(F && f)
> {
> return detail::thread_data_ptr(detail::heap_new<detail::thread_data<typename boost::remove_reference<F>::type> >(
> boost::forward<F>(f)));
> }
>
> static inline detail::thread_data_ptr make_thread_info(void (*f)())
> {
> return detail::thread_data_ptr(detail::heap_new<detail::thread_data<void(*)()> >(
> boost::forward<void(*)()>(f)));
> }
># 240 "/usr/include/boost/thread/detail/thread.hpp" 3 4
> public:
>
>
>
>
>
> thread() noexcept;
> ~thread()
> {
>
>
>
>
>
>
> detach();
>
> }
>
> template <
> class F
> >
> explicit thread(F && f
>
> ):
> thread_info(make_thread_info(thread_detail::decay_copy(boost::forward<F>(f))))
> {
> start_thread();
> }
> template <
> class F
> >
> thread(attributes const& attrs, F && f):
> thread_info(make_thread_info(thread_detail::decay_copy(boost::forward<F>(f))))
> {
> start_thread(attrs);
> }
># 337 "/usr/include/boost/thread/detail/thread.hpp" 3 4
> thread(thread && x)
> {
> thread_info=x.thread_info;
> x.thread_info.reset();
> }
># 352 "/usr/include/boost/thread/detail/thread.hpp" 3 4
> thread& operator=(thread && other) noexcept
> {
>
>
>
>
> thread_info=other.thread_info;
> other.thread_info.reset();
> return *this;
> }
># 387 "/usr/include/boost/thread/detail/thread.hpp" 3 4
> template <class F,class A1>
> thread(F f,A1 a1,typename disable_if<boost::thread_detail::is_convertible<F&,thread_attributes >, dummy* >::type=0):
> thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1)))
> {
> start_thread();
> }
> template <class F,class A1,class A2>
> thread(F f,A1 a1,A2 a2):
> thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2)))
> {
> start_thread();
> }
>
> template <class F,class A1,class A2,class A3>
> thread(F f,A1 a1,A2 a2,A3 a3):
> thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3)))
> {
> start_thread();
> }
>
> template <class F,class A1,class A2,class A3,class A4>
> thread(F f,A1 a1,A2 a2,A3 a3,A4 a4):
> thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4)))
> {
> start_thread();
> }
>
> template <class F,class A1,class A2,class A3,class A4,class A5>
> thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5):
> thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5)))
> {
> start_thread();
> }
>
> template <class F,class A1,class A2,class A3,class A4,class A5,class A6>
> thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6):
> thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6)))
> {
> start_thread();
> }
>
> template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
> thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7):
> thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7)))
> {
> start_thread();
> }
>
> template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
> thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8):
> thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8)))
> {
> start_thread();
> }
>
> template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
> thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9):
> thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8,a9)))
> {
> start_thread();
> }
>
> void swap(thread& x) noexcept
> {
> thread_info.swap(x.thread_info);
> }
>
> class id;
>
> inline id get_id() const noexcept;
>
>
>
>
>
> bool joinable() const noexcept;
> private:
> bool join_noexcept();
> public:
> inline void join();
>
>
> template <class Rep, class Period>
> bool try_join_for(const chrono::duration<Rep, Period>& rel_time)
> {
> return try_join_until(chrono::steady_clock::now() + rel_time);
> }
> template <class Clock, class Duration>
> bool try_join_until(const chrono::time_point<Clock, Duration>& t)
> {
> using namespace chrono;
> system_clock::time_point s_now = system_clock::now();
> bool joined= false;
> do {
> typename Clock::duration d = ceil<nanoseconds>(t-Clock::now());
> if (d <= Clock::duration::zero()) return false;
> joined = try_join_until(s_now + d);
> } while (! joined);
> return true;
> }
> template <class Duration>
> bool try_join_until(const chrono::time_point<chrono::system_clock, Duration>& t)
> {
> using namespace chrono;
> typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
> return try_join_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
> }
># 515 "/usr/include/boost/thread/detail/thread.hpp" 3 4
> private:
> bool do_try_join_until_noexcept(struct timespec const &timeout, bool& res);
> inline bool do_try_join_until(struct timespec const &timeout);
> public:
>
> bool timed_join(const system_time& abs_time)
> {
> struct timespec const ts=detail::to_timespec(abs_time);
> return do_try_join_until(ts);
> }
>
>
> bool try_join_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
> {
> using namespace chrono;
> nanoseconds d = tp.time_since_epoch();
> timespec ts = boost::detail::to_timespec(d);
> return do_try_join_until(ts);
> }
>
>
>
> public:
>
>
> template<typename TimeDuration>
> inline bool timed_join(TimeDuration const& rel_time)
> {
> return timed_join(get_system_time()+rel_time);
> }
>
> void detach();
>
> static unsigned hardware_concurrency() noexcept;
>
>
> typedef detail::thread_data_base::native_handle_type native_handle_type;
> native_handle_type native_handle();
>
>
>
>
> bool operator==(const thread& other) const;
> bool operator!=(const thread& other) const;
>
>
> static inline void yield() noexcept
> {
> this_thread::yield();
> }
>
> static inline void sleep(const system_time& xt)
> {
> this_thread::sleep(xt);
> }
>
>
>
>
> void interrupt();
> bool interruption_requested() const noexcept;
>
> };
>
> inline void swap(thread& lhs,thread& rhs) noexcept
> {
> return lhs.swap(rhs);
> }
>
>
> inline thread&& move(thread& t) noexcept
> {
> return static_cast<thread&&>(t);
> }
>
>
> 
>
> namespace this_thread
> {
>
> inline thread::id get_id() noexcept;
>
>
>
>
>
> void __attribute__((__visibility__("default"))) interruption_point();
> bool __attribute__((__visibility__("default"))) interruption_enabled() noexcept;
> bool __attribute__((__visibility__("default"))) interruption_requested() noexcept;
>
>
>
> inline __attribute__((__visibility__("default"))) void sleep(xtime const& abs_time)
> {
> sleep(system_time(abs_time));
> }
>
> }
>
> class __attribute__((__visibility__("default"))) thread::id
> {
> private:
> friend inline
> std::size_t
> hash_value(const thread::id &v)
> {
>
> return hash_value(v.thread_data);
>
>
>
> }
>
>
>
>
>
> typedef thread::native_handle_type data;
>
>
>
>
> data thread_data;
>
> id(data thread_data_):
> thread_data(thread_data_)
> {}
> friend class thread;
> friend id __attribute__((__visibility__("default"))) this_thread::get_id() noexcept;
> public:
> id() noexcept:
>
> thread_data(0)
>
>
>
> {}
>
> id(const id& other) noexcept :
> thread_data(other.thread_data)
> {}
>
> bool operator==(const id& y) const noexcept
> {
> return thread_data==y.thread_data;
> }
>
> bool operator!=(const id& y) const noexcept
> {
> return thread_data!=y.thread_data;
> }
>
> bool operator<(const id& y) const noexcept
> {
> return thread_data<y.thread_data;
> }
>
> bool operator>(const id& y) const noexcept
> {
> return y.thread_data<thread_data;
> }
>
> bool operator<=(const id& y) const noexcept
> {
> return !(y.thread_data<thread_data);
> }
>
> bool operator>=(const id& y) const noexcept
> {
> return !(thread_data<y.thread_data);
> }
>
>
>
> template<class charT, class traits>
> friend __attribute__((__visibility__("default")))
> std::basic_ostream<charT, traits>&
> operator<<(std::basic_ostream<charT, traits>& os, const id& x)
> {
> if(x.thread_data)
> {
> io::ios_flags_saver ifs( os );
> return os<< std::hex << x.thread_data;
> }
> else
> {
> return os<<"{Not-any-thread}";
> }
> }
># 724 "/usr/include/boost/thread/detail/thread.hpp" 3 4
> };
>
>
> thread::id thread::get_id() const noexcept
> {
>
> return const_cast<thread*>(this)->native_handle();
>
>
>
>
> }
>
> namespace this_thread
> {
> inline thread::id get_id() noexcept
> {
>
> return pthread_self();
>
>
>
>
> }
> }
>
> void thread::join() {
> if (this_thread::get_id() == get_id())
> boost::throw_exception(thread_resource_error(system::errc::resource_deadlock_would_occur, "boost thread: trying joining itself"));
>
> (void)(join_noexcept())
>
> ;
> }
>
>
> bool thread::do_try_join_until(struct timespec const &timeout)
>
>
>
> {
> if (this_thread::get_id() == get_id())
> boost::throw_exception(thread_resource_error(system::errc::resource_deadlock_would_occur, "boost thread: trying joining itself"));
> bool res;
> if (do_try_join_until_noexcept(timeout, res))
> {
> return res;
> }
> else
> {
> return (false)
>
>
> ;
> }
> }
># 792 "/usr/include/boost/thread/detail/thread.hpp" 3 4
> inline bool thread::operator==(const thread& other) const
> {
> return get_id()==other.get_id();
> }
>
> inline bool thread::operator!=(const thread& other) const
> {
> return get_id()!=other.get_id();
> }
>
>
> namespace detail
> {
> struct thread_exit_function_base
> {
> virtual ~thread_exit_function_base()
> {}
> virtual void operator()()=0;
> };
>
> template<typename F>
> struct thread_exit_function:
> thread_exit_function_base
> {
> F f;
>
> thread_exit_function(F f_):
> f(f_)
> {}
>
> void operator()()
> {
> f();
> }
> };
>
> void __attribute__((__visibility__("default"))) add_thread_exit_function(thread_exit_function_base*);
> }
>
> namespace this_thread
> {
> template<typename F>
> void at_thread_exit(F f)
> {
> detail::thread_exit_function_base* const thread_exit_func=detail::heap_new<detail::thread_exit_function<F> >(f);
> detail::add_thread_exit_function(thread_exit_func);
> }
> }
>}
>
>
>
>
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 847 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4
># 23 "/usr/include/boost/thread/thread_only.hpp" 2 3 4
>
># 1 "/usr/include/boost/thread/detail/thread_interruption.hpp" 1 3 4
># 14 "/usr/include/boost/thread/detail/thread_interruption.hpp" 3 4
>namespace boost
>{
> namespace this_thread
> {
> class __attribute__((__visibility__("default"))) disable_interruption
> {
> bool interruption_was_enabled;
> friend class restore_interruption;
> public:
> disable_interruption(disable_interruption const&) = delete; disable_interruption& operator=(disable_interruption const&) = delete;
> disable_interruption() noexcept;
> ~disable_interruption() noexcept;
> };
>
> class __attribute__((__visibility__("default"))) restore_interruption
> {
> public:
> restore_interruption(restore_interruption const&) = delete; restore_interruption& operator=(restore_interruption const&) = delete;
> explicit restore_interruption(disable_interruption& d) noexcept;
> ~restore_interruption() noexcept;
> };
> }
>}
># 25 "/usr/include/boost/thread/thread_only.hpp" 2 3 4
>
># 1 "/usr/include/boost/thread/v2/thread.hpp" 1 3 4
># 14 "/usr/include/boost/thread/v2/thread.hpp" 3 4
># 1 "/usr/include/boost/thread/condition_variable.hpp" 1 3 4
># 16 "/usr/include/boost/thread/condition_variable.hpp" 3 4
># 1 "/usr/include/boost/thread/pthread/condition_variable.hpp" 1 3 4
># 21 "/usr/include/boost/thread/pthread/condition_variable.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 22 "/usr/include/boost/thread/pthread/condition_variable.hpp" 2 3 4
>
>namespace boost
>{
>
> namespace this_thread
> {
> void __attribute__((__visibility__("default"))) interruption_point();
> }
>
>
> namespace thread_cv_detail
> {
> template<typename MutexType>
> struct lock_on_exit
> {
> MutexType* m;
>
> lock_on_exit():
> m(0)
> {}
>
> void activate(MutexType& m_)
> {
> m_.unlock();
> m=&m_;
> }
> ~lock_on_exit()
> {
> if(m)
> {
> m->lock();
> }
> }
> };
> }
>
> inline void condition_variable::wait(unique_lock<mutex>& m)
> {
>
>
>
>
>
>
> int res=0;
> {
>
> thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
> detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
> guard.activate(m);
> do {
> res = pthread_cond_wait(&cond,&internal_mutex);
> } while (res == 4);
>
>
>
>
>
>
>
> }
>
> this_thread::interruption_point();
>
> if(res)
> {
> boost::throw_exception(condition_error(res, "boost::condition_variable::wait failed in pthread_cond_wait"));
> }
> }
>
> inline bool condition_variable::do_wait_until(
> unique_lock<mutex>& m,
> struct timespec const &timeout)
> {
>
>
>
>
>
>
> thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
> int cond_res;
> {
>
> detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
> guard.activate(m);
> cond_res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
>
>
>
>
>
> }
>
> this_thread::interruption_point();
>
> if(cond_res==110)
> {
> return false;
> }
> if(cond_res)
> {
> boost::throw_exception(condition_error(cond_res, "boost::condition_variable::do_wait_until failed in pthread_cond_timedwait"));
> }
> return true;
> }
>
> inline void condition_variable::notify_one() noexcept
> {
>
> boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
>
> ((void)(!pthread_cond_signal(&cond)));
> }
>
> inline void condition_variable::notify_all() noexcept
> {
>
> boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
>
> ((void)(!pthread_cond_broadcast(&cond)));
> }
>
> class condition_variable_any
> {
> pthread_mutex_t internal_mutex;
> pthread_cond_t cond;
>
> public:
> condition_variable_any(condition_variable_any const&) = delete; condition_variable_any& operator=(condition_variable_any const&) = delete;
> condition_variable_any()
> {
> int const res=pthread_mutex_init(&internal_mutex,__null);
> if(res)
> {
> boost::throw_exception(thread_resource_error(res, "boost::condition_variable_any::condition_variable_any() failed in pthread_mutex_init"));
> }
> int const res2=pthread_cond_init(&cond,__null);
> if(res2)
> {
> ((void)(!pthread_mutex_destroy(&internal_mutex)));
> boost::throw_exception(thread_resource_error(res, "boost::condition_variable_any::condition_variable_any() failed in pthread_cond_init"));
> }
> }
> ~condition_variable_any()
> {
> ((void)(!pthread_mutex_destroy(&internal_mutex)));
> ((void)(!pthread_cond_destroy(&cond)));
> }
>
> template<typename lock_type>
> void wait(lock_type& m)
> {
> int res=0;
> {
> thread_cv_detail::lock_on_exit<lock_type> guard;
>
> detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
>
>
>
> guard.activate(m);
> res=pthread_cond_wait(&cond,&internal_mutex);
> }
>
> this_thread::interruption_point();
>
> if(res)
> {
> boost::throw_exception(condition_error(res, "boost::condition_variable_any::wait() failed in pthread_cond_wait"));
> }
> }
>
> template<typename lock_type,typename predicate_type>
> void wait(lock_type& m,predicate_type pred)
> {
> while(!pred()) wait(m);
> }
>
>
> template<typename lock_type>
> bool timed_wait(lock_type& m,boost::system_time const& a_wait_until)
> {
> struct timespec const timeout=detail::to_timespec(a_wait_until);
> return do_wait_until(m, timeout);
> }
> template<typename lock_type>
> bool timed_wait(lock_type& m,xtime const& a_wait_until)
> {
> return timed_wait(m,system_time(a_wait_until));
> }
>
> template<typename lock_type,typename duration_type>
> bool timed_wait(lock_type& m,duration_type const& wait_duration)
> {
> return timed_wait(m,get_system_time()+wait_duration);
> }
>
> template<typename lock_type,typename predicate_type>
> bool timed_wait(lock_type& m,boost::system_time const& a_wait_until,predicate_type pred)
> {
> while (!pred())
> {
> if(!timed_wait(m, a_wait_until))
> return pred();
> }
> return true;
> }
>
> template<typename lock_type,typename predicate_type>
> bool timed_wait(lock_type& m,xtime const& a_wait_until,predicate_type pred)
> {
> return timed_wait(m,system_time(a_wait_until),pred);
> }
>
> template<typename lock_type,typename duration_type,typename predicate_type>
> bool timed_wait(lock_type& m,duration_type const& wait_duration,predicate_type pred)
> {
> return timed_wait(m,get_system_time()+wait_duration,pred);
> }
>
>
> template <class lock_type,class Duration>
> cv_status
> wait_until(
> lock_type& lock,
> const chrono::time_point<chrono::system_clock, Duration>& t)
> {
> using namespace chrono;
> typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
> wait_until(lock,
> nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
> return system_clock::now() < t ? cv_status::no_timeout :
> cv_status::timeout;
> }
>
> template <class lock_type, class Clock, class Duration>
> cv_status
> wait_until(
> lock_type& lock,
> const chrono::time_point<Clock, Duration>& t)
> {
> using namespace chrono;
> system_clock::time_point s_now = system_clock::now();
> typename Clock::time_point c_now = Clock::now();
> wait_until(lock, s_now + ceil<nanoseconds>(t - c_now));
> return Clock::now() < t ? cv_status::no_timeout : cv_status::timeout;
> }
>
> template <class lock_type, class Clock, class Duration, class Predicate>
> bool
> wait_until(
> lock_type& lock,
> const chrono::time_point<Clock, Duration>& t,
> Predicate pred)
> {
> while (!pred())
> {
> if (wait_until(lock, t) == cv_status::timeout)
> return pred();
> }
> return true;
> }
>
>
> template <class lock_type, class Rep, class Period>
> cv_status
> wait_for(
> lock_type& lock,
> const chrono::duration<Rep, Period>& d)
> {
> using namespace chrono;
> system_clock::time_point s_now = system_clock::now();
> steady_clock::time_point c_now = steady_clock::now();
> wait_until(lock, s_now + ceil<nanoseconds>(d));
> return steady_clock::now() - c_now < d ? cv_status::no_timeout :
> cv_status::timeout;
>
> }
>
>
> template <class lock_type, class Rep, class Period, class Predicate>
> bool
> wait_for(
> lock_type& lock,
> const chrono::duration<Rep, Period>& d,
> Predicate pred)
> {
> return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));
>
>
>
>
>
>
>
> }
>
> template <class lock_type>
> cv_status wait_until(
> lock_type& lk,
> chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp)
> {
> using namespace chrono;
> nanoseconds d = tp.time_since_epoch();
> timespec ts = boost::detail::to_timespec(d);
> if (do_wait_until(lk, ts)) return cv_status::no_timeout;
> else return cv_status::timeout;
> }
>
>
> void notify_one() noexcept
> {
> boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
> ((void)(!pthread_cond_signal(&cond)));
> }
>
> void notify_all() noexcept
> {
> boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
> ((void)(!pthread_cond_broadcast(&cond)));
> }
> private:
>
> template <class lock_type>
> inline bool do_wait_until(
> lock_type& m,
> struct timespec const &timeout)
> {
> int res=0;
> {
> thread_cv_detail::lock_on_exit<lock_type> guard;
>
> detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
>
>
>
> guard.activate(m);
> res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
> }
>
> this_thread::interruption_point();
>
> if(res==110)
> {
> return false;
> }
> if(res)
> {
> boost::throw_exception(condition_error(res, "boost::condition_variable_any::do_wait_until() failed in pthread_cond_timedwait"));
> }
> return true;
> }
>
>
> };
>
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 382 "/usr/include/boost/thread/pthread/condition_variable.hpp" 2 3 4
># 17 "/usr/include/boost/thread/condition_variable.hpp" 2 3 4
># 15 "/usr/include/boost/thread/v2/thread.hpp" 2 3 4
>
>
>namespace boost
>{
> namespace this_thread
> {
>
>
>
> template <class Clock, class Duration>
> void sleep_until(const chrono::time_point<Clock, Duration>& t)
> {
> using namespace chrono;
> mutex mut;
> condition_variable cv;
> unique_lock<mutex> lk(mut);
> while (Clock::now() < t)
> cv.wait_until(lk, t);
> }
>
>
>
> template <class Rep, class Period>
> void sleep_for(const chrono::duration<Rep, Period>& d)
> {
> using namespace chrono;
> if (d > duration<Rep, Period>::zero())
> {
> duration<long double> Max = nanoseconds::max ();
> nanoseconds ns;
> if (d < Max)
> {
> ns = duration_cast<nanoseconds>(d);
> if (ns < d)
> ++ns;
> }
> else
> ns = nanoseconds:: max ();
> sleep_for(ns);
> }
> }
>
> template <class Duration>
> inline __attribute__((__visibility__("default")))
> void sleep_until(const chrono::time_point<chrono::steady_clock, Duration>& t)
> {
> using namespace chrono;
> sleep_for(t - steady_clock::now());
> }
># 79 "/usr/include/boost/thread/v2/thread.hpp" 3 4
> }
>}
># 27 "/usr/include/boost/thread/thread_only.hpp" 2 3 4
># 13 "/usr/include/boost/thread/thread.hpp" 2 3 4
># 1 "/usr/include/boost/thread/detail/thread_group.hpp" 1 3 4
># 9 "/usr/include/boost/thread/detail/thread_group.hpp" 3 4
># 1 "/usr/include/boost/thread/shared_mutex.hpp" 1 3 4
># 22 "/usr/include/boost/thread/shared_mutex.hpp" 3 4
># 1 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 1 3 4
># 11 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 12 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 2 3 4
># 23 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 24 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 2 3 4
>
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 26 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 2 3 4
>
>namespace boost
>{
> class shared_mutex
> {
> private:
> class state_data
> {
> public:
> state_data () :
> shared_count(0),
> exclusive(false),
> upgrade(false),
> exclusive_waiting_blocked(false)
> {}
>
> void assert_free() const
> {
> ((void)0);
> ((void)0);
> ((void)0);
> }
>
> void assert_locked() const
> {
> ((void)0);
> ((void)0);
> ((void)0);
> }
>
> void assert_lock_shared () const
> {
> ((void)0);
> ((void)0);
>
>
>
> }
>
> void assert_lock_upgraded () const
> {
> ((void)0);
> ((void)0);
> ((void)0);
> }
>
> void assert_lock_not_upgraded () const
> {
> ((void)0);
> }
>
> bool can_lock () const
> {
> return ! (shared_count || exclusive);
> }
>
> void exclusive_blocked (bool blocked)
> {
> exclusive_waiting_blocked = blocked;
> }
>
> void lock ()
> {
> exclusive = true;
> }
>
> void unlock ()
> {
> exclusive = false;
> exclusive_waiting_blocked = false;
> }
>
> bool can_lock_shared () const
> {
> return ! (exclusive || exclusive_waiting_blocked);
> }
>
> bool more_shared () const
> {
> return shared_count > 0 ;
> }
> unsigned get_shared_count () const
> {
> return shared_count ;
> }
> unsigned lock_shared ()
> {
> return ++shared_count;
> }
>
>
> void unlock_shared ()
> {
> --shared_count;
> }
>
> bool unlock_shared_downgrades()
> {
> if (upgrade) {
> upgrade=false;
> exclusive=true;
> return true;
> } else {
> exclusive_waiting_blocked=false;
> return false;
> }
> }
>
> void lock_upgrade ()
> {
> ++shared_count;
> upgrade=true;
> }
> bool can_lock_upgrade () const
> {
> return ! (exclusive || exclusive_waiting_blocked || upgrade);
> }
>
> void unlock_upgrade ()
> {
> upgrade=false;
> --shared_count;
> }
>
>
> unsigned shared_count;
> bool exclusive;
> bool upgrade;
> bool exclusive_waiting_blocked;
> };
>
>
>
> state_data state;
> boost::mutex state_change;
> boost::condition_variable shared_cond;
> boost::condition_variable exclusive_cond;
> boost::condition_variable upgrade_cond;
>
> void release_waiters()
> {
> exclusive_cond.notify_one();
> shared_cond.notify_all();
> }
>
> public:
>
> shared_mutex(shared_mutex const&) = delete; shared_mutex& operator=(shared_mutex const&) = delete;
>
> shared_mutex()
> {
> }
>
> ~shared_mutex()
> {
> }
>
> void lock_shared()
> {
>
> boost::this_thread::disable_interruption do_not_disturb;
>
> boost::unique_lock<boost::mutex> lk(state_change);
> while(!state.can_lock_shared())
> {
> shared_cond.wait(lk);
> }
> state.lock_shared();
> }
>
> bool try_lock_shared()
> {
> boost::unique_lock<boost::mutex> lk(state_change);
>
> if(!state.can_lock_shared())
> {
> return false;
> }
> state.lock_shared();
> return true;
> }
>
>
> bool timed_lock_shared(system_time const& timeout)
> {
>
> boost::this_thread::disable_interruption do_not_disturb;
>
> boost::unique_lock<boost::mutex> lk(state_change);
>
> while(!state.can_lock_shared())
> {
> if(!shared_cond.timed_wait(lk,timeout))
> {
> return false;
> }
> }
> state.lock_shared();
> return true;
> }
>
> template<typename TimeDuration>
> bool timed_lock_shared(TimeDuration const & relative_time)
> {
> return timed_lock_shared(get_system_time()+relative_time);
> }
>
>
> template <class Rep, class Period>
> bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time)
> {
> return try_lock_shared_until(chrono::steady_clock::now() + rel_time);
> }
> template <class Clock, class Duration>
> bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time)
> {
>
> boost::this_thread::disable_interruption do_not_disturb;
>
> boost::unique_lock<boost::mutex> lk(state_change);
>
> while(!state.can_lock_shared())
>
> {
> if(cv_status::timeout==shared_cond.wait_until(lk,abs_time))
> {
> return false;
> }
> }
> state.lock_shared();
> return true;
> }
>
> void unlock_shared()
> {
> boost::unique_lock<boost::mutex> lk(state_change);
> state.assert_lock_shared();
> state.unlock_shared();
> if (! state.more_shared())
> {
> if (state.upgrade)
> {
>
>
> state.upgrade=false;
> state.exclusive=true;
> lk.unlock();
> upgrade_cond.notify_one();
> }
> else
> {
> state.exclusive_waiting_blocked=false;
> lk.unlock();
> }
> release_waiters();
> }
> }
>
> void lock()
> {
>
> boost::this_thread::disable_interruption do_not_disturb;
>
> boost::unique_lock<boost::mutex> lk(state_change);
>
> while (state.shared_count || state.exclusive)
> {
> state.exclusive_waiting_blocked=true;
> exclusive_cond.wait(lk);
> }
> state.exclusive=true;
> }
>
>
> bool timed_lock(system_time const& timeout)
> {
>
> boost::this_thread::disable_interruption do_not_disturb;
>
> boost::unique_lock<boost::mutex> lk(state_change);
>
> while(state.shared_count || state.exclusive)
> {
> state.exclusive_waiting_blocked=true;
> if(!exclusive_cond.timed_wait(lk,timeout))
> {
> if(state.shared_count || state.exclusive)
> {
> state.exclusive_waiting_blocked=false;
> release_waiters();
> return false;
> }
> break;
> }
> }
> state.exclusive=true;
> return true;
> }
>
> template<typename TimeDuration>
> bool timed_lock(TimeDuration const & relative_time)
> {
> return timed_lock(get_system_time()+relative_time);
> }
>
>
> template <class Rep, class Period>
> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
> {
> return try_lock_until(chrono::steady_clock::now() + rel_time);
> }
> template <class Clock, class Duration>
> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
> {
>
> boost::this_thread::disable_interruption do_not_disturb;
>
> boost::unique_lock<boost::mutex> lk(state_change);
>
> while(state.shared_count || state.exclusive)
> {
> state.exclusive_waiting_blocked=true;
> if(cv_status::timeout == exclusive_cond.wait_until(lk,abs_time))
> {
> if(state.shared_count || state.exclusive)
> {
> state.exclusive_waiting_blocked=false;
> release_waiters();
> return false;
> }
> break;
> }
> }
> state.exclusive=true;
> return true;
> }
>
>
> bool try_lock()
> {
> boost::unique_lock<boost::mutex> lk(state_change);
>
> if(state.shared_count || state.exclusive)
> {
> return false;
> }
> else
> {
> state.exclusive=true;
> return true;
> }
>
> }
>
> void unlock()
> {
> boost::unique_lock<boost::mutex> lk(state_change);
> state.assert_locked();
> state.exclusive=false;
> state.exclusive_waiting_blocked=false;
> state.assert_free();
> release_waiters();
> }
>
> void lock_upgrade()
> {
>
> boost::this_thread::disable_interruption do_not_disturb;
>
> boost::unique_lock<boost::mutex> lk(state_change);
> while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
> {
> shared_cond.wait(lk);
> }
> state.lock_shared();
> state.upgrade=true;
> }
>
>
> bool timed_lock_upgrade(system_time const& timeout)
> {
>
> boost::this_thread::disable_interruption do_not_disturb;
>
> boost::unique_lock<boost::mutex> lk(state_change);
> while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
> {
> if(!shared_cond.timed_wait(lk,timeout))
> {
> if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
> {
> return false;
> }
> break;
> }
> }
> state.lock_shared();
> state.upgrade=true;
> return true;
> }
>
> template<typename TimeDuration>
> bool timed_lock_upgrade(TimeDuration const & relative_time)
> {
> return timed_lock_upgrade(get_system_time()+relative_time);
> }
>
>
> template <class Rep, class Period>
> bool try_lock_upgrade_for(const chrono::duration<Rep, Period>& rel_time)
> {
> return try_lock_upgrade_until(chrono::steady_clock::now() + rel_time);
> }
> template <class Clock, class Duration>
> bool try_lock_upgrade_until(const chrono::time_point<Clock, Duration>& abs_time)
> {
>
> boost::this_thread::disable_interruption do_not_disturb;
>
> boost::unique_lock<boost::mutex> lk(state_change);
> while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
> {
> if(cv_status::timeout == shared_cond.wait_until(lk,abs_time))
> {
> if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
> {
> return false;
> }
> break;
> }
> }
> state.lock_shared();
> state.upgrade=true;
> return true;
> }
>
> bool try_lock_upgrade()
> {
> boost::unique_lock<boost::mutex> lk(state_change);
> if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
> {
> return false;
> }
> else
> {
> state.lock_shared();
> state.upgrade=true;
> state.assert_lock_upgraded();
> return true;
> }
> }
>
> void unlock_upgrade()
> {
> boost::unique_lock<boost::mutex> lk(state_change);
>
> state.unlock_upgrade();
> if(! state.more_shared() )
> {
> state.exclusive_waiting_blocked=false;
> release_waiters();
> } else {
> shared_cond.notify_all();
> }
> }
>
>
> void unlock_upgrade_and_lock()
> {
>
> boost::this_thread::disable_interruption do_not_disturb;
>
> boost::unique_lock<boost::mutex> lk(state_change);
> state.assert_lock_upgraded();
> state.unlock_shared();
> while (state.more_shared())
> {
> upgrade_cond.wait(lk);
> }
> state.upgrade=false;
> state.exclusive=true;
> state.assert_locked();
> }
>
> void unlock_and_lock_upgrade()
> {
> boost::unique_lock<boost::mutex> lk(state_change);
> state.assert_locked();
> state.exclusive=false;
> state.upgrade=true;
> state.lock_shared();
> state.exclusive_waiting_blocked=false;
> state.assert_lock_upgraded();
> release_waiters();
> }
>
> bool try_unlock_upgrade_and_lock()
> {
> boost::unique_lock<boost::mutex> lk(state_change);
> state.assert_lock_upgraded();
> if( !state.exclusive
> && !state.exclusive_waiting_blocked
> && state.upgrade
> && state.shared_count==1)
> {
> state.shared_count=0;
> state.exclusive=true;
> state.upgrade=false;
> state.assert_locked();
> return true;
> }
> return false;
> }
>
> template <class Rep, class Period>
> bool
> try_unlock_upgrade_and_lock_for(
> const chrono::duration<Rep, Period>& rel_time)
> {
> return try_unlock_upgrade_and_lock_until(
> chrono::steady_clock::now() + rel_time);
> }
> template <class Clock, class Duration>
> bool
> try_unlock_upgrade_and_lock_until(
> const chrono::time_point<Clock, Duration>& abs_time)
> {
>
> boost::this_thread::disable_interruption do_not_disturb;
>
> boost::unique_lock<boost::mutex> lk(state_change);
> state.assert_lock_upgraded();
> if (state.shared_count != 1)
> {
> for (;;)
> {
> cv_status status = shared_cond.wait_until(lk,abs_time);
> if (state.shared_count == 1)
> break;
> if(status == cv_status::timeout)
> return false;
> }
> }
> state.upgrade=false;
> state.exclusive=true;
> state.exclusive_waiting_blocked=false;
> state.shared_count=0;
> return true;
> }
>
>
>
> void unlock_and_lock_shared()
> {
> boost::unique_lock<boost::mutex> lk(state_change);
> state.assert_locked();
> state.exclusive=false;
> state.lock_shared();
> state.exclusive_waiting_blocked=false;
> release_waiters();
> }
># 644 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 3 4
> void unlock_upgrade_and_lock_shared()
> {
> boost::unique_lock<boost::mutex> lk(state_change);
> state.assert_lock_upgraded();
> state.upgrade=false;
> state.exclusive_waiting_blocked=false;
> release_waiters();
> }
># 709 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 3 4
> };
>
> typedef shared_mutex upgrade_mutex;
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 715 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 2 3 4
># 23 "/usr/include/boost/thread/shared_mutex.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost
>{
> namespace sync
> {
># 46 "/usr/include/boost/thread/shared_mutex.hpp" 3 4
> }
>}
># 10 "/usr/include/boost/thread/detail/thread_group.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 14 "/usr/include/boost/thread/detail/thread_group.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost
>{
> class thread_group
> {
> private:
> thread_group(thread_group const&);
> thread_group& operator=(thread_group const&);
> public:
> thread_group() {}
> ~thread_group()
> {
> for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
> it!=end;
> ++it)
> {
> delete *it;
> }
> }
>
> bool is_this_thread_in()
> {
> thread::id id = this_thread::get_id();
> boost::shared_lock<shared_mutex> guard(m);
> for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
> it!=end;
> ++it)
> {
> if ((*it)->get_id() == id)
> return true;
> }
> return false;
> }
>
> bool is_thread_in(thread* thrd)
> {
> if(thrd)
> {
> thread::id id = thrd->get_id();
> boost::shared_lock<shared_mutex> guard(m);
> for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
> it!=end;
> ++it)
> {
> if ((*it)->get_id() == id)
> return true;
> }
> return false;
> }
> else
> {
> return false;
> }
> }
>
> template<typename F>
> thread* create_thread(F threadfunc)
> {
> boost::lock_guard<shared_mutex> guard(m);
> std::auto_ptr<thread> new_thread(new thread(threadfunc));
> threads.push_back(new_thread.get());
> return new_thread.release();
> }
>
> void add_thread(thread* thrd)
> {
> if(thrd)
> {
> 
>
> ;
>
> boost::lock_guard<shared_mutex> guard(m);
> threads.push_back(thrd);
> }
> }
>
> void remove_thread(thread* thrd)
> {
> boost::lock_guard<shared_mutex> guard(m);
> std::list<thread*>::iterator const it=std::find(threads.begin(),threads.end(),thrd);
> if(it!=threads.end())
> {
> threads.erase(it);
> }
> }
>
> void join_all()
> {
> 
>
> ;
> boost::shared_lock<shared_mutex> guard(m);
>
> for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
> it!=end;
> ++it)
> {
> if ((*it)->joinable())
> (*it)->join();
> }
> }
>
>
> void interrupt_all()
> {
> boost::shared_lock<shared_mutex> guard(m);
>
> for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
> it!=end;
> ++it)
> {
> (*it)->interrupt();
> }
> }
>
>
> size_t size() const
> {
> boost::shared_lock<shared_mutex> guard(m);
> return threads.size();
> }
>
> private:
> std::list<thread*> threads;
> mutable shared_mutex m;
> };
>}
>
>
>
>
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 153 "/usr/include/boost/thread/detail/thread_group.hpp" 2 3 4
># 14 "/usr/include/boost/thread/thread.hpp" 2 3 4
># 14 "/usr/include/boost/thread.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/thread/once.hpp" 1 3 4
># 20 "/usr/include/boost/thread/once.hpp" 3 4
># 1 "/usr/include/boost/thread/pthread/once_atomic.hpp" 1 3 4
># 15 "/usr/include/boost/thread/pthread/once_atomic.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 16 "/usr/include/boost/thread/pthread/once_atomic.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/atomic.hpp" 1 3 4
># 12 "/usr/include/boost/atomic.hpp" 3 4
># 1 "/usr/include/boost/atomic/atomic.hpp" 1 3 4
># 11 "/usr/include/boost/atomic/atomic.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 12 "/usr/include/boost/atomic/atomic.hpp" 2 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 13 "/usr/include/boost/atomic/atomic.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/atomic/detail/config.hpp" 1 3 4
># 17 "/usr/include/boost/atomic/detail/config.hpp" 3 4
> 
># 50 "/usr/include/boost/atomic/detail/config.hpp" 3 4
># 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
># 51 "/usr/include/boost/atomic/detail/config.hpp" 2 3 4
># 17 "/usr/include/boost/atomic/atomic.hpp" 2 3 4
># 1 "/usr/include/boost/atomic/detail/platform.hpp" 1 3 4
># 15 "/usr/include/boost/atomic/detail/platform.hpp" 3 4
> 
>
>
>
>
># 1 "/usr/include/boost/atomic/detail/gcc-x86.hpp" 1 3 4
># 11 "/usr/include/boost/atomic/detail/gcc-x86.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 12 "/usr/include/boost/atomic/detail/gcc-x86.hpp" 2 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 13 "/usr/include/boost/atomic/detail/gcc-x86.hpp" 2 3 4
>
>
>
> 
>
>
>namespace boost {
>namespace atomics {
>namespace detail {
># 40 "/usr/include/boost/atomic/detail/gcc-x86.hpp" 3 4
>inline void
>platform_fence_before(memory_order order)
>{
> switch(order)
> {
> case memory_order_relaxed:
> case memory_order_acquire:
> case memory_order_consume:
> break;
> case memory_order_release:
> case memory_order_acq_rel:
> __asm__ __volatile__ ("" ::: "memory");
>
> break;
> case memory_order_seq_cst:
> __asm__ __volatile__ ("" ::: "memory");
>
> break;
> default:;
> }
>}
>
>inline void
>platform_fence_after(memory_order order)
>{
> switch(order)
> {
> case memory_order_relaxed:
> case memory_order_release:
> break;
> case memory_order_acquire:
> case memory_order_acq_rel:
> __asm__ __volatile__ ("" ::: "memory");
>
> break;
> case memory_order_consume:
>
> break;
> case memory_order_seq_cst:
> __asm__ __volatile__ ("" ::: "memory");
>
> break;
> default:;
> }
>}
>
>inline void
>platform_fence_after_load(memory_order order)
>{
> switch(order)
> {
> case memory_order_relaxed:
> case memory_order_release:
> break;
> case memory_order_acquire:
> case memory_order_acq_rel:
> __asm__ __volatile__ ("" ::: "memory");
> break;
> case memory_order_consume:
> break;
> case memory_order_seq_cst:
> __asm__ __volatile__ ("" ::: "memory");
> break;
> default:;
> }
>}
>
>inline void
>platform_fence_before_store(memory_order order)
>{
> switch(order)
> {
> case memory_order_relaxed:
> case memory_order_acquire:
> case memory_order_consume:
> break;
> case memory_order_release:
> case memory_order_acq_rel:
> __asm__ __volatile__ ("" ::: "memory");
>
> break;
> case memory_order_seq_cst:
> __asm__ __volatile__ ("" ::: "memory");
>
> break;
> default:;
> }
>}
>
>inline void
>platform_fence_after_store(memory_order order)
>{
> switch(order)
> {
> case memory_order_relaxed:
> case memory_order_release:
> break;
> case memory_order_acquire:
> case memory_order_acq_rel:
> __asm__ __volatile__ ("" ::: "memory");
>
> break;
> case memory_order_consume:
>
> break;
> case memory_order_seq_cst:
> __asm__ __volatile__ ("" ::: "memory");
>
> break;
> default:;
> }
>}
>
>}
>}
>
>class atomic_flag
>{
>private:
> atomic_flag(const atomic_flag &) ;
> atomic_flag & operator=(const atomic_flag &) ;
> uint32_t v_;
>public:
> constexpr atomic_flag(void) noexcept : v_(0) {}
>
> bool
> test_and_set(memory_order order = memory_order_seq_cst) volatile noexcept
> {
> uint32_t v = 1;
> atomics::detail::platform_fence_before(order);
> __asm__ __volatile__ (
> "xchgl %0, %1"
> : "+r" (v), "+m" (v_)
> );
> atomics::detail::platform_fence_after(order);
> return v;
> }
>
> void
> clear(memory_order order = memory_order_seq_cst) volatile noexcept
> {
> if (order == memory_order_seq_cst) {
> uint32_t v = 0;
> __asm__ __volatile__ (
> "xchgl %0, %1"
> : "+r" (v), "+m" (v_)
> );
> } else {
> atomics::detail::platform_fence_before(order);
> v_ = 0;
> }
> }
>};
>
>}
>
>
>
># 1 "/usr/include/boost/atomic/detail/base.hpp" 1 3 4
># 17 "/usr/include/boost/atomic/detail/base.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 18 "/usr/include/boost/atomic/detail/base.hpp" 2 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 19 "/usr/include/boost/atomic/detail/base.hpp" 2 3 4
>
># 1 "/usr/include/boost/atomic/detail/lockpool.hpp" 1 3 4
># 16 "/usr/include/boost/atomic/detail/lockpool.hpp" 3 4
> 
>
>
>namespace boost {
>namespace atomics {
>namespace detail {
># 55 "/usr/include/boost/atomic/detail/lockpool.hpp" 3 4
>class lockpool
>{
>public:
> typedef atomic_flag lock_type;
>
> class scoped_lock
> {
> private:
> atomic_flag& flag_;
> uint8_t padding[128 - sizeof(atomic_flag)];
>
> scoped_lock(const scoped_lock &) ;
> scoped_lock& operator=(const scoped_lock &) ;
>
> public:
> explicit
> scoped_lock(const volatile void * addr) : flag_(get_lock_for(addr))
> {
> for (; flag_.test_and_set(memory_order_acquire);)
> {
>
> __asm__ __volatile__ ("pause\n");
>
> }
> }
>
> ~scoped_lock(void)
> {
> flag_.clear(memory_order_release);
> }
> };
>
>private:
> static lock_type& get_lock_for(const volatile void * addr);
>};
>
>
>
>}
>}
>}
># 21 "/usr/include/boost/atomic/detail/base.hpp" 2 3 4
>
>
> 
># 151 "/usr/include/boost/atomic/detail/base.hpp" 3 4
>namespace boost {
>namespace atomics {
>namespace detail {
>
>inline memory_order
>calculate_failure_order(memory_order order)
>{
> switch(order) {
> case memory_order_acq_rel:
> return memory_order_acquire;
> case memory_order_release:
> return memory_order_relaxed;
> default:
> return order;
> }
>}
>
>template<typename T, typename C, unsigned int Size, bool Sign>
>class base_atomic
>{
>private:
> typedef base_atomic this_type;
> typedef T value_type;
> typedef lockpool::scoped_lock guard_type;
> typedef char storage_type[sizeof(value_type)];
>
>public:
> base_atomic(void) {}
>
> constexpr explicit base_atomic(value_type const& v) noexcept : v_(v)
> {}
>
> void
> store(value_type const& v, memory_order = memory_order_seq_cst) volatile noexcept
> {
> char * storage = storage_ptr();
> guard_type guard(storage);
>
> memcpy(storage, &v, sizeof(value_type));
> }
>
> value_type
> load(memory_order = memory_order_seq_cst) volatile const noexcept
> {
> char * storage = storage_ptr();
> guard_type guard(storage);
>
> value_type v;
> memcpy(&v, storage, sizeof(value_type));
> return v;
> }
>
> bool
> compare_exchange_strong(
> value_type & expected,
> value_type const& desired,
> memory_order ,
> memory_order ) volatile noexcept
> {
> char * storage = storage_ptr();
> guard_type guard(storage);
>
> if (memcmp(storage, &expected, sizeof(value_type)) == 0) {
> memcpy(storage, &desired, sizeof(value_type));
> return true;
> } else {
> memcpy(&expected, storage, sizeof(value_type));
> return false;
> }
> }
>
> bool
> compare_exchange_weak(
> value_type & expected,
> value_type const& desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> return compare_exchange_strong(expected, desired, success_order, failure_order);
> }
>
> value_type
> exchange(value_type const& v, memory_order =memory_order_seq_cst) volatile noexcept
> {
> char * storage = storage_ptr();
> guard_type guard(storage);
>
> value_type tmp;
> memcpy(&tmp, storage, sizeof(value_type));
>
> memcpy(storage, &v, sizeof(value_type));
> return tmp;
> }
>
> bool
> is_lock_free(void) const volatile noexcept
> {
> return false;
> }
>
> bool compare_exchange_strong( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); } bool compare_exchange_weak( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); }
>private:
> char * storage_ptr() volatile const noexcept
> {
> return const_cast<char *>(&reinterpret_cast<char const volatile &>(v_));
> }
>
> base_atomic(const base_atomic &) ;
> void operator=(const base_atomic &) ;
>
> T v_;
>};
>
>template<typename T, unsigned int Size, bool Sign>
>class base_atomic<T, int, Size, Sign>
>{
>private:
> typedef base_atomic this_type;
> typedef T value_type;
> typedef T difference_type;
> typedef lockpool::scoped_lock guard_type;
>public:
> constexpr explicit base_atomic(value_type v) noexcept : v_(v) {}
> base_atomic(void) {}
>
> void
> store(value_type v, memory_order = memory_order_seq_cst) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> v_ = v;
> }
>
> value_type
> load(memory_order = memory_order_seq_cst) const volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> value_type v = const_cast<const volatile value_type &>(v_);
> return v;
> }
>
> value_type
> exchange(value_type v, memory_order = memory_order_seq_cst) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> value_type old = v_;
> v_ = v;
> return old;
> }
>
> bool
> compare_exchange_strong(value_type & expected, value_type desired,
> memory_order ,
> memory_order ) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> if (v_ == expected) {
> v_ = desired;
> return true;
> } else {
> expected = v_;
> return false;
> }
> }
>
> bool
> compare_exchange_weak(value_type & expected, value_type desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> return compare_exchange_strong(expected, desired, success_order, failure_order);
> }
>
> value_type
> fetch_add(difference_type v, memory_order = memory_order_seq_cst) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> value_type old = v_;
> v_ += v;
> return old;
> }
>
> value_type
> fetch_sub(difference_type v, memory_order = memory_order_seq_cst) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> value_type old = v_;
> v_ -= v;
> return old;
> }
>
> value_type
> fetch_and(value_type v, memory_order = memory_order_seq_cst) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> value_type old = v_;
> v_ &= v;
> return old;
> }
>
> value_type
> fetch_or(value_type v, memory_order = memory_order_seq_cst) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> value_type old = v_;
> v_ |= v;
> return old;
> }
>
> value_type
> fetch_xor(value_type v, memory_order = memory_order_seq_cst) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> value_type old = v_;
> v_ ^= v;
> return old;
> }
>
> bool
> is_lock_free(void) const volatile noexcept
> {
> return false;
> }
>
> bool compare_exchange_strong( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); } bool compare_exchange_weak( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); } value_type operator++(int) volatile noexcept { return fetch_add(1); } value_type operator++(void) volatile noexcept { return fetch_add(1) + 1; } value_type operator--(int) volatile noexcept { return fetch_sub(1); } value_type operator--(void) volatile noexcept { return fetch_sub(1) - 1; } value_type operator+=(difference_type v) volatile noexcept { return fetch_add(v) + v; } value_type operator-=(difference_type v) volatile noexcept { return fetch_sub(v) - v; } value_type operator&=(difference_type v) volatile noexcept { return fetch_and(v) & v; } value_type operator|=(difference_type v) volatile noexcept { return fetch_or(v) | v; } value_type operator^=(difference_type v) volatile noexcept { return fetch_xor(v) ^ v; }
>private:
> base_atomic(const base_atomic &) ;
> void operator=(const base_atomic &) ;
> value_type v_;
>};
>
>template<typename T, unsigned int Size, bool Sign>
>class base_atomic<T *, void *, Size, Sign>
>{
>private:
> typedef base_atomic this_type;
> typedef T * value_type;
> typedef ptrdiff_t difference_type;
> typedef lockpool::scoped_lock guard_type;
>public:
> constexpr explicit base_atomic(value_type v) noexcept : v_(v) {}
> base_atomic(void) {}
>
> void
> store(value_type v, memory_order = memory_order_seq_cst) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
> v_ = v;
> }
>
> value_type
> load(memory_order = memory_order_seq_cst) const volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> value_type v = const_cast<const volatile value_type &>(v_);
> return v;
> }
>
> value_type
> exchange(value_type v, memory_order = memory_order_seq_cst) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> value_type old = v_;
> v_ = v;
> return old;
> }
>
> bool
> compare_exchange_strong(value_type & expected, value_type desired,
> memory_order ,
> memory_order ) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> if (v_ == expected) {
> v_ = desired;
> return true;
> } else {
> expected = v_;
> return false;
> }
> }
>
> bool
> compare_exchange_weak(value_type & expected, value_type desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> return compare_exchange_strong(expected, desired, success_order, failure_order);
> }
>
> value_type fetch_add(difference_type v, memory_order = memory_order_seq_cst) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> value_type old = v_;
> v_ += v;
> return old;
> }
>
> value_type fetch_sub(difference_type v, memory_order = memory_order_seq_cst) volatile
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> value_type old = v_;
> v_ -= v;
> return old;
> }
>
> bool
> is_lock_free(void) const volatile noexcept
> {
> return false;
> }
>
> bool compare_exchange_strong( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); } bool compare_exchange_weak( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); } value_type operator++(int) volatile noexcept { return fetch_add(1); } value_type operator++(void) volatile noexcept { return fetch_add(1) + 1; } value_type operator--(int) volatile noexcept { return fetch_sub(1); } value_type operator--(void) volatile noexcept { return fetch_sub(1) - 1; } value_type operator+=(difference_type v) volatile noexcept { return fetch_add(v) + v; } value_type operator-=(difference_type v) volatile noexcept { return fetch_sub(v) - v; }
>private:
> base_atomic(const base_atomic &) ;
> void operator=(const base_atomic &) ;
> value_type v_;
>};
>
>template<unsigned int Size, bool Sign>
>class base_atomic<void *, void *, Size, Sign>
>{
>private:
> typedef base_atomic this_type;
> typedef ptrdiff_t difference_type;
> typedef void * value_type;
> typedef lockpool::scoped_lock guard_type;
>public:
> constexpr explicit base_atomic(value_type v) noexcept : v_(v) {}
> base_atomic(void) {}
>
> void
> store(value_type v, memory_order = memory_order_seq_cst) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
> v_ = v;
> }
>
> value_type
> load(memory_order = memory_order_seq_cst) const volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> value_type v = const_cast<const volatile value_type &>(v_);
> return v;
> }
>
> value_type
> exchange(value_type v, memory_order = memory_order_seq_cst) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> value_type old = v_;
> v_ = v;
> return old;
> }
>
> bool
> compare_exchange_strong(value_type & expected, value_type desired,
> memory_order ,
> memory_order ) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> if (v_ == expected) {
> v_ = desired;
> return true;
> } else {
> expected = v_;
> return false;
> }
> }
>
> bool
> compare_exchange_weak(value_type & expected, value_type desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> return compare_exchange_strong(expected, desired, success_order, failure_order);
> }
>
> bool
> is_lock_free(void) const volatile noexcept
> {
> return false;
> }
>
> value_type fetch_add(difference_type v, memory_order = memory_order_seq_cst) volatile noexcept
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> value_type old = v_;
> char * cv = reinterpret_cast<char*>(old);
> cv += v;
> v_ = cv;
> return old;
> }
>
> value_type fetch_sub(difference_type v, memory_order = memory_order_seq_cst) volatile
> {
> guard_type guard(const_cast<value_type *>(&v_));
>
> value_type old = v_;
> char * cv = reinterpret_cast<char*>(old);
> cv -= v;
> v_ = cv;
> return old;
> }
>
> bool compare_exchange_strong( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); } bool compare_exchange_weak( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); } value_type operator++(int) volatile noexcept { return fetch_add(1); } value_type operator++(void) volatile noexcept { return (char*)fetch_add(1) + 1; } value_type operator--(int) volatile noexcept { return fetch_sub(1); } value_type operator--(void) volatile noexcept { return (char*)fetch_sub(1) - 1; } value_type operator+=(difference_type v) volatile noexcept { return (char*)fetch_add(v) + v; } value_type operator-=(difference_type v) volatile noexcept { return (char*)fetch_sub(v) - v; }
>
>private:
> base_atomic(const base_atomic &) ;
> void operator=(const base_atomic &) ;
> value_type v_;
>};
>
>}
>}
>}
># 199 "/usr/include/boost/atomic/detail/gcc-x86.hpp" 2 3 4
># 219 "/usr/include/boost/atomic/detail/gcc-x86.hpp" 3 4
>namespace boost {
>
>
>inline void
>atomic_thread_fence(memory_order order)
>{
> switch(order)
> {
> case memory_order_relaxed:
> break;
> case memory_order_release:
> __asm__ __volatile__ ("" ::: "memory");
> break;
> case memory_order_acquire:
> __asm__ __volatile__ ("" ::: "memory");
> break;
> case memory_order_acq_rel:
> __asm__ __volatile__ ("" ::: "memory");
> break;
> case memory_order_consume:
> break;
> case memory_order_seq_cst:
> __asm__ __volatile__ ("mfence\n" ::: "memory");
> break;
> default:;
> }
>}
>
>
>inline void
>atomic_signal_fence(memory_order)
>{
> __asm__ __volatile__ ("" ::: "memory");
>}
>
>namespace atomics {
>namespace detail {
>
>template<typename T, bool Sign>
>class base_atomic<T, int, 1, Sign>
>{
> typedef base_atomic this_type;
> typedef T value_type;
> typedef T difference_type;
>public:
> constexpr explicit base_atomic(value_type v) noexcept : v_(v) {}
> base_atomic(void) {}
>
> void
> store(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> if (order != memory_order_seq_cst) {
> platform_fence_before(order);
> const_cast<volatile value_type &>(v_) = v;
> } else {
> exchange(v, order);
> }
> }
>
> value_type
> load(memory_order order = memory_order_seq_cst) const volatile noexcept
> {
> value_type v = const_cast<const volatile value_type &>(v_);
> platform_fence_after_load(order);
> return v;
> }
>
> value_type
> fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> platform_fence_before(order);
> __asm__ (
> "lock ; xaddb %0, %1"
> : "+q" (v), "+m" (v_)
> );
> platform_fence_after(order);
> return v;
> }
>
> value_type
> fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> return fetch_add(-v, order);
> }
>
> value_type
> exchange(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> platform_fence_before(order);
> __asm__ (
> "xchgb %0, %1"
> : "+q" (v), "+m" (v_)
> );
> platform_fence_after(order);
> return v;
> }
>
> bool
> compare_exchange_strong(
> value_type & expected,
> value_type desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> value_type previous = expected;
> platform_fence_before(success_order);
> __asm__ (
> "lock ; cmpxchgb %2, %1"
> : "+a" (previous), "+m" (v_)
> : "q" (desired)
> );
> bool success = (previous == expected);
> if (success)
> platform_fence_after(success_order);
> else
> platform_fence_after(failure_order);
> expected = previous;
> return success;
> }
>
> bool
> compare_exchange_weak(
> value_type & expected,
> value_type desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> return compare_exchange_strong(expected, desired, success_order, failure_order);
> }
>
> value_type
> fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> value_type tmp = load(memory_order_relaxed);
> for(; !compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed);)
> {
> __asm__ __volatile__ ("pause\n");
> }
> return tmp;
> }
>
> value_type
> fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> value_type tmp = load(memory_order_relaxed);
> for (; !compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed);)
> {
> __asm__ __volatile__ ("pause\n");
> }
> return tmp;
> }
>
> value_type
> fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> value_type tmp = load(memory_order_relaxed);
> for (; !compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed);)
> {
> __asm__ __volatile__ ("pause\n");
> }
> return tmp;
> }
>
> bool
> is_lock_free(void) const volatile noexcept
> {
> return true;
> }
>
> bool compare_exchange_strong( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); } bool compare_exchange_weak( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); } value_type operator++(int) volatile noexcept { return fetch_add(1); } value_type operator++(void) volatile noexcept { return fetch_add(1) + 1; } value_type operator--(int) volatile noexcept { return fetch_sub(1); } value_type operator--(void) volatile noexcept { return fetch_sub(1) - 1; } value_type operator+=(difference_type v) volatile noexcept { return fetch_add(v) + v; } value_type operator-=(difference_type v) volatile noexcept { return fetch_sub(v) - v; } value_type operator&=(difference_type v) volatile noexcept { return fetch_and(v) & v; } value_type operator|=(difference_type v) volatile noexcept { return fetch_or(v) | v; } value_type operator^=(difference_type v) volatile noexcept { return fetch_xor(v) ^ v; }
>private:
> base_atomic(const base_atomic &) ;
> void operator=(const base_atomic &) ;
> value_type v_;
>};
>
>template<typename T, bool Sign>
>class base_atomic<T, int, 2, Sign>
>{
> typedef base_atomic this_type;
> typedef T value_type;
> typedef T difference_type;
>public:
> constexpr explicit base_atomic(value_type v) noexcept : v_(v) {}
> base_atomic(void) {}
>
> void
> store(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> if (order != memory_order_seq_cst) {
> platform_fence_before(order);
> const_cast<volatile value_type &>(v_) = v;
> } else {
> exchange(v, order);
> }
> }
>
> value_type
> load(memory_order order = memory_order_seq_cst) const volatile noexcept
> {
> value_type v = const_cast<const volatile value_type &>(v_);
> platform_fence_after_load(order);
> return v;
> }
>
> value_type
> fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> platform_fence_before(order);
> __asm__ (
> "lock ; xaddw %0, %1"
> : "+q" (v), "+m" (v_)
> );
> platform_fence_after(order);
> return v;
> }
>
> value_type
> fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> return fetch_add(-v, order);
> }
>
> value_type
> exchange(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> platform_fence_before(order);
> __asm__ (
> "xchgw %0, %1"
> : "+q" (v), "+m" (v_)
> );
> platform_fence_after(order);
> return v;
> }
>
> bool
> compare_exchange_strong(
> value_type & expected,
> value_type desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> value_type previous = expected;
> platform_fence_before(success_order);
> __asm__ (
> "lock ; cmpxchgw %2, %1"
> : "+a" (previous), "+m" (v_)
> : "q" (desired)
> );
> bool success = (previous == expected);
> if (success)
> platform_fence_after(success_order);
> else
> platform_fence_after(failure_order);
> expected = previous;
> return success;
> }
>
> bool
> compare_exchange_weak(
> value_type & expected,
> value_type desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> return compare_exchange_strong(expected, desired, success_order, failure_order);
> }
>
> value_type
> fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> value_type tmp = load(memory_order_relaxed);
> for (; !compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed);)
> {
> __asm__ __volatile__ ("pause\n");
> }
> return tmp;
> }
>
> value_type
> fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> value_type tmp = load(memory_order_relaxed);
> for (; !compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed);)
> {
> __asm__ __volatile__ ("pause\n");
> }
> return tmp;
> }
>
> value_type
> fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> value_type tmp = load(memory_order_relaxed);
> for (; !compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed);)
> {
> __asm__ __volatile__ ("pause\n");
> }
> return tmp;
> }
>
> bool
> is_lock_free(void) const volatile noexcept
> {
> return true;
> }
>
> bool compare_exchange_strong( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); } bool compare_exchange_weak( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); } value_type operator++(int) volatile noexcept { return fetch_add(1); } value_type operator++(void) volatile noexcept { return fetch_add(1) + 1; } value_type operator--(int) volatile noexcept { return fetch_sub(1); } value_type operator--(void) volatile noexcept { return fetch_sub(1) - 1; } value_type operator+=(difference_type v) volatile noexcept { return fetch_add(v) + v; } value_type operator-=(difference_type v) volatile noexcept { return fetch_sub(v) - v; } value_type operator&=(difference_type v) volatile noexcept { return fetch_and(v) & v; } value_type operator|=(difference_type v) volatile noexcept { return fetch_or(v) | v; } value_type operator^=(difference_type v) volatile noexcept { return fetch_xor(v) ^ v; }
>private:
> base_atomic(const base_atomic &) ;
> void operator=(const base_atomic &) ;
> value_type v_;
>};
>
>template<typename T, bool Sign>
>class base_atomic<T, int, 4, Sign>
>{
> typedef base_atomic this_type;
> typedef T value_type;
> typedef T difference_type;
>public:
> constexpr explicit base_atomic(value_type v) noexcept : v_(v) {}
> base_atomic(void) {}
>
> void
> store(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> if (order != memory_order_seq_cst) {
> platform_fence_before(order);
> const_cast<volatile value_type &>(v_) = v;
> } else {
> exchange(v, order);
> }
> }
>
> value_type
> load(memory_order order = memory_order_seq_cst) const volatile noexcept
> {
> value_type v = const_cast<const volatile value_type &>(v_);
> platform_fence_after_load(order);
> return v;
> }
>
> value_type
> fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> platform_fence_before(order);
> __asm__ (
> "lock ; xaddl %0, %1"
> : "+r" (v), "+m" (v_)
> );
> platform_fence_after(order);
> return v;
> }
>
> value_type
> fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> return fetch_add(-v, order);
> }
>
> value_type
> exchange(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> platform_fence_before(order);
> __asm__ (
> "xchgl %0, %1"
> : "+r" (v), "+m" (v_)
> );
> platform_fence_after(order);
> return v;
> }
>
> bool
> compare_exchange_strong(
> value_type & expected,
> value_type desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> value_type previous = expected;
> platform_fence_before(success_order);
> __asm__ (
> "lock ; cmpxchgl %2, %1"
> : "+a" (previous), "+m" (v_)
> : "r" (desired)
> );
> bool success = (previous == expected);
> if (success)
> platform_fence_after(success_order);
> else
> platform_fence_after(failure_order);
> expected = previous;
> return success;
> }
>
> bool
> compare_exchange_weak(
> value_type & expected,
> value_type desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> return compare_exchange_strong(expected, desired, success_order, failure_order);
> }
>
> value_type
> fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> value_type tmp = load(memory_order_relaxed);
> for (; !compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed);)
> {
> __asm__ __volatile__ ("pause\n");
> }
> return tmp;
> }
>
> value_type
> fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> value_type tmp = load(memory_order_relaxed);
> for (; !compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed);)
> {
> __asm__ __volatile__ ("pause\n");
> }
> return tmp;
> }
>
> value_type
> fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> value_type tmp = load(memory_order_relaxed);
> for (; !compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed);)
> {
> __asm__ __volatile__ ("pause\n");
> }
> return tmp;
> }
>
> bool
> is_lock_free(void) const volatile noexcept
> {
> return true;
> }
>
> bool compare_exchange_strong( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); } bool compare_exchange_weak( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); } value_type operator++(int) volatile noexcept { return fetch_add(1); } value_type operator++(void) volatile noexcept { return fetch_add(1) + 1; } value_type operator--(int) volatile noexcept { return fetch_sub(1); } value_type operator--(void) volatile noexcept { return fetch_sub(1) - 1; } value_type operator+=(difference_type v) volatile noexcept { return fetch_add(v) + v; } value_type operator-=(difference_type v) volatile noexcept { return fetch_sub(v) - v; } value_type operator&=(difference_type v) volatile noexcept { return fetch_and(v) & v; } value_type operator|=(difference_type v) volatile noexcept { return fetch_or(v) | v; } value_type operator^=(difference_type v) volatile noexcept { return fetch_xor(v) ^ v; }
>private:
> base_atomic(const base_atomic &) ;
> void operator=(const base_atomic &) ;
> value_type v_;
>};
>
>
>template<typename T, bool Sign>
>class base_atomic<T, int, 8, Sign>
>{
> typedef base_atomic this_type;
> typedef T value_type;
> typedef T difference_type;
>public:
> constexpr explicit base_atomic(value_type v) noexcept : v_(v) {}
> base_atomic(void) {}
>
> void
> store(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> if (order != memory_order_seq_cst) {
> platform_fence_before(order);
> const_cast<volatile value_type &>(v_) = v;
> } else {
> exchange(v, order);
> }
> }
>
> value_type
> load(memory_order order = memory_order_seq_cst) const volatile noexcept
> {
> value_type v = const_cast<const volatile value_type &>(v_);
> platform_fence_after_load(order);
> return v;
> }
>
> value_type
> fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> platform_fence_before(order);
> __asm__ (
> "lock ; xaddq %0, %1"
> : "+r" (v), "+m" (v_)
> );
> platform_fence_after(order);
> return v;
> }
>
> value_type
> fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> return fetch_add(-v, order);
> }
>
> value_type
> exchange(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> platform_fence_before(order);
> __asm__ (
> "xchgq %0, %1"
> : "+r" (v), "+m" (v_)
> );
> platform_fence_after(order);
> return v;
> }
>
> bool
> compare_exchange_strong(
> value_type & expected,
> value_type desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> value_type previous = expected;
> platform_fence_before(success_order);
> __asm__ (
> "lock ; cmpxchgq %2, %1"
> : "+a" (previous), "+m" (v_)
> : "r" (desired)
> );
> bool success = (previous == expected);
> if (success)
> platform_fence_after(success_order);
> else
> platform_fence_after(failure_order);
> expected = previous;
> return success;
> }
>
> bool
> compare_exchange_weak(
> value_type & expected,
> value_type desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> return compare_exchange_strong(expected, desired, success_order, failure_order);
> }
>
> value_type
> fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> value_type tmp = load(memory_order_relaxed);
> for (; !compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed);)
> {
> __asm__ __volatile__ ("pause\n");
> }
> return tmp;
> }
>
> value_type
> fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> value_type tmp = load(memory_order_relaxed);
> for (; !compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed);)
> {
> __asm__ __volatile__ ("pause\n");
> }
> return tmp;
> }
>
> value_type
> fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> value_type tmp = load(memory_order_relaxed);
> for (; !compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed);)
> {
> __asm__ __volatile__ ("pause\n");
> }
> return tmp;
> }
>
> bool
> is_lock_free(void) const volatile noexcept
> {
> return true;
> }
>
> bool compare_exchange_strong( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); } bool compare_exchange_weak( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); } value_type operator++(int) volatile noexcept { return fetch_add(1); } value_type operator++(void) volatile noexcept { return fetch_add(1) + 1; } value_type operator--(int) volatile noexcept { return fetch_sub(1); } value_type operator--(void) volatile noexcept { return fetch_sub(1) - 1; } value_type operator+=(difference_type v) volatile noexcept { return fetch_add(v) + v; } value_type operator-=(difference_type v) volatile noexcept { return fetch_sub(v) - v; } value_type operator&=(difference_type v) volatile noexcept { return fetch_and(v) & v; } value_type operator|=(difference_type v) volatile noexcept { return fetch_or(v) | v; } value_type operator^=(difference_type v) volatile noexcept { return fetch_xor(v) ^ v; }
>private:
> base_atomic(const base_atomic &) ;
> void operator=(const base_atomic &) ;
> value_type v_;
>};
># 1021 "/usr/include/boost/atomic/detail/gcc-x86.hpp" 3 4
>template<bool Sign>
>class base_atomic<void *, void *, 8, Sign>
>{
> typedef base_atomic this_type;
> typedef ptrdiff_t difference_type;
> typedef void * value_type;
>public:
> constexpr explicit base_atomic(value_type v) noexcept : v_(v) {}
> base_atomic(void) {}
>
> void
> store(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> if (order != memory_order_seq_cst) {
> platform_fence_before(order);
> const_cast<volatile value_type &>(v_) = v;
> } else {
> exchange(v, order);
> }
> }
>
> value_type load(memory_order order = memory_order_seq_cst) const volatile noexcept
> {
> value_type v = const_cast<const volatile value_type &>(v_);
> platform_fence_after_load(order);
> return v;
> }
>
> value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> platform_fence_before(order);
> __asm__ (
> "xchgq %0, %1"
> : "+r" (v), "+m" (v_)
> );
> platform_fence_after(order);
> return v;
> }
>
> bool compare_exchange_strong(value_type & expected, value_type desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> value_type previous = expected;
> platform_fence_before(success_order);
> __asm__ (
> "lock ; cmpxchgq %2, %1"
> : "+a" (previous), "+m" (v_)
> : "r" (desired)
> );
> bool success = (previous == expected);
> if (success)
> platform_fence_after(success_order);
> else
> platform_fence_after(failure_order);
> expected = previous;
> return success;
> }
>
> bool compare_exchange_weak(value_type & expected, value_type desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> return compare_exchange_strong(expected, desired, success_order, failure_order);
> }
>
> bool
> is_lock_free(void) const volatile noexcept
> {
> return true;
> }
>
> value_type
> fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> platform_fence_before(order);
> __asm__ (
> "lock ; xaddq %0, %1"
> : "+r" (v), "+m" (v_)
> );
> platform_fence_after(order);
> return reinterpret_cast<value_type>(v);
> }
>
> value_type
> fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> return fetch_add(-v, order);
> }
>
> bool compare_exchange_strong( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); } bool compare_exchange_weak( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); } value_type operator++(int) volatile noexcept { return fetch_add(1); } value_type operator++(void) volatile noexcept { return (char*)fetch_add(1) + 1; } value_type operator--(int) volatile noexcept { return fetch_sub(1); } value_type operator--(void) volatile noexcept { return (char*)fetch_sub(1) - 1; } value_type operator+=(difference_type v) volatile noexcept { return (char*)fetch_add(v) + v; } value_type operator-=(difference_type v) volatile noexcept { return (char*)fetch_sub(v) - v; }
>private:
> base_atomic(const base_atomic &) ;
> void operator=(const base_atomic &) ;
> value_type v_;
>};
>
>template<typename T, bool Sign>
>class base_atomic<T *, void *, 8, Sign>
>{
> typedef base_atomic this_type;
> typedef T * value_type;
> typedef ptrdiff_t difference_type;
>public:
> constexpr explicit base_atomic(value_type v) noexcept : v_(v) {}
> base_atomic(void) {}
>
> void
> store(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> if (order != memory_order_seq_cst) {
> platform_fence_before(order);
> const_cast<volatile value_type &>(v_) = v;
> } else {
> exchange(v, order);
> }
> }
>
> value_type
> load(memory_order order = memory_order_seq_cst) const volatile noexcept
> {
> value_type v = const_cast<const volatile value_type &>(v_);
> platform_fence_after_load(order);
> return v;
> }
>
> value_type
> exchange(value_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> platform_fence_before(order);
> __asm__ (
> "xchgq %0, %1"
> : "+r" (v), "+m" (v_)
> );
> platform_fence_after(order);
> return v;
> }
>
> bool
> compare_exchange_strong(
> value_type & expected,
> value_type desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> value_type previous = expected;
> platform_fence_before(success_order);
> __asm__ (
> "lock ; cmpxchgq %2, %1"
> : "+a" (previous), "+m" (v_)
> : "r" (desired)
> );
> bool success = (previous == expected);
> if (success)
> platform_fence_after(success_order);
> else
> platform_fence_after(failure_order);
> expected = previous;
> return success;
> }
>
> bool
> compare_exchange_weak(
> value_type & expected,
> value_type desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> return compare_exchange_strong(expected, desired, success_order, failure_order);
> }
>
> value_type
> fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> v = v * sizeof(*v_);
> platform_fence_before(order);
> __asm__ (
> "lock ; xaddq %0, %1"
> : "+r" (v), "+m" (v_)
> );
> platform_fence_after(order);
> return reinterpret_cast<value_type>(v);
> }
>
> value_type
> fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> return fetch_add(-v, order);
> }
>
> bool
> is_lock_free(void) const volatile noexcept
> {
> return true;
> }
>
> bool compare_exchange_strong( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); } bool compare_exchange_weak( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); } value_type operator++(int) volatile noexcept { return fetch_add(1); } value_type operator++(void) volatile noexcept { return fetch_add(1) + 1; } value_type operator--(int) volatile noexcept { return fetch_sub(1); } value_type operator--(void) volatile noexcept { return fetch_sub(1) - 1; } value_type operator+=(difference_type v) volatile noexcept { return fetch_add(v) + v; } value_type operator-=(difference_type v) volatile noexcept { return fetch_sub(v) - v; }
>private:
> base_atomic(const base_atomic &) ;
> void operator=(const base_atomic &) ;
> value_type v_;
>};
>
>
>
>template<typename T, bool Sign>
>class base_atomic<T, void, 1, Sign>
>{
> typedef base_atomic this_type;
> typedef T value_type;
> typedef uint8_t storage_type;
>public:
> constexpr explicit base_atomic(value_type const& v) noexcept :
> v_(reinterpret_cast<storage_type const&>(v))
> {}
> base_atomic(void) {}
>
> void
> store(value_type const& v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> if (order != memory_order_seq_cst) {
> storage_type tmp;
> memcpy(&tmp, &v, sizeof(value_type));
> platform_fence_before(order);
> const_cast<volatile storage_type &>(v_) = tmp;
> } else {
> exchange(v, order);
> }
> }
>
> value_type
> load(memory_order order = memory_order_seq_cst) const volatile noexcept
> {
> storage_type tmp = const_cast<volatile storage_type &>(v_);
> platform_fence_after_load(order);
> value_type v;
> memcpy(&v, &tmp, sizeof(value_type));
> return v;
> }
>
> value_type
> exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> storage_type tmp;
> memcpy(&tmp, &v, sizeof(value_type));
> platform_fence_before(order);
> __asm__ (
> "xchgb %0, %1"
> : "+q" (tmp), "+m" (v_)
> );
> platform_fence_after(order);
> value_type res;
> memcpy(&res, &tmp, sizeof(value_type));
> return res;
> }
>
> bool
> compare_exchange_strong(
> value_type & expected,
> value_type const& desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> storage_type expected_s, desired_s;
> memcpy(&expected_s, &expected, sizeof(value_type));
> memcpy(&desired_s, &desired, sizeof(value_type));
> storage_type previous_s = expected_s;
> platform_fence_before(success_order);
> __asm__ (
> "lock ; cmpxchgb %2, %1"
> : "+a" (previous_s), "+m" (v_)
> : "q" (desired_s)
> );
> bool success = (previous_s == expected_s);
> if (success)
> platform_fence_after(success_order);
> else
> platform_fence_after(failure_order);
> memcpy(&expected, &previous_s, sizeof(value_type));
> return success;
> }
>
> bool
> compare_exchange_weak(
> value_type & expected,
> value_type const& desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> return compare_exchange_strong(expected, desired, success_order, failure_order);
> }
>
> bool
> is_lock_free(void) const volatile noexcept
> {
> return true;
> }
>
> bool compare_exchange_strong( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); } bool compare_exchange_weak( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); }
>private:
> base_atomic(const base_atomic &) ;
> void operator=(const base_atomic &) ;
> storage_type v_;
>};
>
>template<typename T, bool Sign>
>class base_atomic<T, void, 2, Sign>
>{
> typedef base_atomic this_type;
> typedef T value_type;
> typedef uint16_t storage_type;
>public:
> constexpr explicit base_atomic(value_type const& v) noexcept :
> v_(reinterpret_cast<storage_type const&>(v))
> {}
> base_atomic(void) {}
>
> void
> store(value_type const& v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> if (order != memory_order_seq_cst) {
> storage_type tmp;
> memcpy(&tmp, &v, sizeof(value_type));
> platform_fence_before(order);
> const_cast<volatile storage_type &>(v_) = tmp;
> } else {
> exchange(v, order);
> }
> }
>
> value_type
> load(memory_order order = memory_order_seq_cst) const volatile noexcept
> {
> storage_type tmp = const_cast<volatile storage_type &>(v_);
> platform_fence_after_load(order);
> value_type v;
> memcpy(&v, &tmp, sizeof(value_type));
> return v;
> }
>
> value_type
> exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> storage_type tmp;
> memcpy(&tmp, &v, sizeof(value_type));
> platform_fence_before(order);
> __asm__ (
> "xchgw %0, %1"
> : "+q" (tmp), "+m" (v_)
> );
> platform_fence_after(order);
> value_type res;
> memcpy(&res, &tmp, sizeof(value_type));
> return res;
> }
>
> bool
> compare_exchange_strong(
> value_type & expected,
> value_type const& desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> storage_type expected_s, desired_s;
> memcpy(&expected_s, &expected, sizeof(value_type));
> memcpy(&desired_s, &desired, sizeof(value_type));
> storage_type previous_s = expected_s;
> platform_fence_before(success_order);
> __asm__ (
> "lock ; cmpxchgw %2, %1"
> : "+a" (previous_s), "+m" (v_)
> : "q" (desired_s)
> );
> bool success = (previous_s == expected_s);
> if (success)
> platform_fence_after(success_order);
> else
> platform_fence_after(failure_order);
> memcpy(&expected, &previous_s, sizeof(value_type));
> return success;
> }
>
> bool
> compare_exchange_weak(
> value_type & expected,
> value_type const& desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> return compare_exchange_strong(expected, desired, success_order, failure_order);
> }
>
> bool
> is_lock_free(void) const volatile noexcept
> {
> return true;
> }
>
> bool compare_exchange_strong( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); } bool compare_exchange_weak( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); }
>private:
> base_atomic(const base_atomic &) ;
> void operator=(const base_atomic &) ;
> storage_type v_;
>};
>
>template<typename T, bool Sign>
>class base_atomic<T, void, 4, Sign>
>{
> typedef base_atomic this_type;
> typedef T value_type;
> typedef uint32_t storage_type;
>public:
> explicit base_atomic(value_type const& v) noexcept : v_(0)
> {
> memcpy(&v_, &v, sizeof(value_type));
> }
> base_atomic(void) {}
>
> void
> store(value_type const& v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> if (order != memory_order_seq_cst) {
> storage_type tmp = 0;
> memcpy(&tmp, &v, sizeof(value_type));
> platform_fence_before(order);
> const_cast<volatile storage_type &>(v_) = tmp;
> } else {
> exchange(v, order);
> }
> }
>
> value_type
> load(memory_order order = memory_order_seq_cst) const volatile noexcept
> {
> storage_type tmp = const_cast<volatile storage_type &>(v_);
> platform_fence_after_load(order);
> value_type v;
> memcpy(&v, &tmp, sizeof(value_type));
> return v;
> }
>
> value_type
> exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> storage_type tmp = 0;
> memcpy(&tmp, &v, sizeof(value_type));
> platform_fence_before(order);
> __asm__ (
> "xchgl %0, %1"
> : "+q" (tmp), "+m" (v_)
> );
> platform_fence_after(order);
> value_type res;
> memcpy(&res, &tmp, sizeof(value_type));
> return res;
> }
>
> bool
> compare_exchange_strong(
> value_type & expected,
> value_type const& desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> storage_type expected_s = 0, desired_s = 0;
> memcpy(&expected_s, &expected, sizeof(value_type));
> memcpy(&desired_s, &desired, sizeof(value_type));
> storage_type previous_s = expected_s;
> platform_fence_before(success_order);
> __asm__ (
> "lock ; cmpxchgl %2, %1"
> : "+a" (previous_s), "+m" (v_)
> : "q" (desired_s)
> );
> bool success = (previous_s == expected_s);
> if (success)
> platform_fence_after(success_order);
> else
> platform_fence_after(failure_order);
> memcpy(&expected, &previous_s, sizeof(value_type));
> return success;
> }
>
> bool
> compare_exchange_weak(
> value_type & expected,
> value_type const& desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> return compare_exchange_strong(expected, desired, success_order, failure_order);
> }
>
> bool
> is_lock_free(void) const volatile noexcept
> {
> return true;
> }
>
> bool compare_exchange_strong( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); } bool compare_exchange_weak( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); }
>private:
> base_atomic(const base_atomic &) ;
> void operator=(const base_atomic &) ;
> storage_type v_;
>};
>
>
>template<typename T, bool Sign>
>class base_atomic<T, void, 8, Sign>
>{
> typedef base_atomic this_type;
> typedef T value_type;
> typedef uint64_t storage_type;
>public:
> explicit base_atomic(value_type const& v) noexcept : v_(0)
> {
> memcpy(&v_, &v, sizeof(value_type));
> }
> base_atomic(void) {}
>
> void
> store(value_type const& v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> if (order != memory_order_seq_cst) {
> storage_type tmp = 0;
> memcpy(&tmp, &v, sizeof(value_type));
> platform_fence_before(order);
> const_cast<volatile storage_type &>(v_) = tmp;
> } else {
> exchange(v, order);
> }
> }
>
> value_type
> load(memory_order order = memory_order_seq_cst) const volatile noexcept
> {
> storage_type tmp = const_cast<volatile storage_type &>(v_);
> platform_fence_after_load(order);
> value_type v;
> memcpy(&v, &tmp, sizeof(value_type));
> return v;
> }
>
> value_type
> exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile noexcept
> {
> storage_type tmp = 0;
> memcpy(&tmp, &v, sizeof(value_type));
> platform_fence_before(order);
> __asm__ (
> "xchgq %0, %1"
> : "+q" (tmp), "+m" (v_)
> );
> platform_fence_after(order);
> value_type res;
> memcpy(&res, &tmp, sizeof(value_type));
> return res;
> }
>
> bool
> compare_exchange_strong(
> value_type & expected,
> value_type const& desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> storage_type expected_s = 0, desired_s = 0;
> memcpy(&expected_s, &expected, sizeof(value_type));
> memcpy(&desired_s, &desired, sizeof(value_type));
> storage_type previous_s = expected_s;
> platform_fence_before(success_order);
> __asm__ (
> "lock ; cmpxchgq %2, %1"
> : "+a" (previous_s), "+m" (v_)
> : "q" (desired_s)
> );
> bool success = (previous_s == expected_s);
> if (success)
> platform_fence_after(success_order);
> else
> platform_fence_after(failure_order);
> memcpy(&expected, &previous_s, sizeof(value_type));
> return success;
> }
>
> bool
> compare_exchange_weak(
> value_type & expected,
> value_type const& desired,
> memory_order success_order,
> memory_order failure_order) volatile noexcept
> {
> return compare_exchange_strong(expected, desired, success_order, failure_order);
> }
>
> bool
> is_lock_free(void) const volatile noexcept
> {
> return true;
> }
>
> bool compare_exchange_strong( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); } bool compare_exchange_weak( value_type & expected, value_type desired, memory_order order = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); }
>private:
> base_atomic(const base_atomic &) ;
> void operator=(const base_atomic &) ;
> storage_type v_;
>};
># 1755 "/usr/include/boost/atomic/detail/gcc-x86.hpp" 3 4
>}
>}
>}
># 21 "/usr/include/boost/atomic/detail/platform.hpp" 2 3 4
># 18 "/usr/include/boost/atomic/atomic.hpp" 2 3 4
># 1 "/usr/include/boost/atomic/detail/type-classification.hpp" 1 3 4
># 14 "/usr/include/boost/atomic/detail/type-classification.hpp" 3 4
> 
>
>
>namespace boost {
>namespace atomics {
>namespace detail {
>
>template<typename T, bool IsInt = boost::is_integral<T>::value>
>struct classify
>{
> typedef void type;
>};
>
>template<typename T>
>struct classify<T, true> {typedef int type;};
>
>template<typename T>
>struct classify<T*, false> {typedef void* type;};
>
>template<typename T>
>struct storage_size_of
>{
> enum _
> {
> size = sizeof(T),
> value = (size == 3 ? 4 : (size == 5 || size == 6 || size == 7 ? 8 : size))
> };
>};
>
>}}}
># 19 "/usr/include/boost/atomic/atomic.hpp" 2 3 4
>
>
>
>
>
>
>
> 
>
>
>namespace boost {
># 88 "/usr/include/boost/atomic/atomic.hpp" 3 4
>template<typename T>
>class atomic :
> public atomics::detail::base_atomic<
> T,
> typename atomics::detail::classify<T>::type,
> atomics::detail::storage_size_of<T>::value,
>
> boost::is_signed<T>::value
>
>
>
>
> >
>{
>private:
> typedef T value_type;
> typedef atomics::detail::base_atomic<
> T,
> typename atomics::detail::classify<T>::type,
> atomics::detail::storage_size_of<T>::value,
>
> boost::is_signed<T>::value
>
>
>
>
> > super;
>public:
> atomic(void) noexcept : super() {}
> constexpr atomic(value_type v) noexcept : super(v) {}
>
> value_type operator=(value_type v) volatile noexcept
> {
> this->store(v);
> return v;
> }
>
> operator value_type(void) volatile const noexcept
> {
> return this->load();
> }
>
>
>
>
>
>
> atomic(const atomic &) = delete;
> atomic & operator=(const atomic &) volatile = delete;
>
>};
>
>typedef atomic<char> atomic_char;
>typedef atomic<unsigned char> atomic_uchar;
>typedef atomic<signed char> atomic_schar;
>typedef atomic<uint8_t> atomic_uint8_t;
>typedef atomic<int8_t> atomic_int8_t;
>typedef atomic<unsigned short> atomic_ushort;
>typedef atomic<short> atomic_short;
>typedef atomic<uint16_t> atomic_uint16_t;
>typedef atomic<int16_t> atomic_int16_t;
>typedef atomic<unsigned int> atomic_uint;
>typedef atomic<int> atomic_int;
>typedef atomic<uint32_t> atomic_uint32_t;
>typedef atomic<int32_t> atomic_int32_t;
>typedef atomic<unsigned long> atomic_ulong;
>typedef atomic<long> atomic_long;
>typedef atomic<uint64_t> atomic_uint64_t;
>typedef atomic<int64_t> atomic_int64_t;
>
>typedef atomic<boost::ulong_long_type> atomic_ullong;
>typedef atomic<boost::long_long_type> atomic_llong;
>
>typedef atomic<void*> atomic_address;
>typedef atomic<bool> atomic_bool;
>typedef atomic<wchar_t> atomic_wchar_t;
>
>typedef atomic<char16_t> atomic_char16_t;
>
>
>typedef atomic<char32_t> atomic_char32_t;
>
>
>typedef atomic<int_least8_t> atomic_int_least8_t;
>typedef atomic<uint_least8_t> atomic_uint_least8_t;
>typedef atomic<int_least16_t> atomic_int_least16_t;
>typedef atomic<uint_least16_t> atomic_uint_least16_t;
>typedef atomic<int_least32_t> atomic_int_least32_t;
>typedef atomic<uint_least32_t> atomic_uint_least32_t;
>typedef atomic<int_least64_t> atomic_int_least64_t;
>typedef atomic<uint_least64_t> atomic_uint_least64_t;
>typedef atomic<int_fast8_t> atomic_int_fast8_t;
>typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
>typedef atomic<int_fast16_t> atomic_int_fast16_t;
>typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
>typedef atomic<int_fast32_t> atomic_int_fast32_t;
>typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
>typedef atomic<int_fast64_t> atomic_int_fast64_t;
>typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
>typedef atomic<intmax_t> atomic_intmax_t;
>typedef atomic<uintmax_t> atomic_uintmax_t;
>
>typedef atomic<std::size_t> atomic_size_t;
>typedef atomic<std::ptrdiff_t> atomic_ptrdiff_t;
># 201 "/usr/include/boost/atomic/atomic.hpp" 3 4
>typedef atomic<intptr_t> atomic_intptr_t;
>typedef atomic<uintptr_t> atomic_uintptr_t;
># 239 "/usr/include/boost/atomic/atomic.hpp" 3 4
>}
># 13 "/usr/include/boost/atomic.hpp" 2 3 4
>
>
> 
># 21 "/usr/include/boost/thread/pthread/once_atomic.hpp" 2 3 4
>
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 23 "/usr/include/boost/thread/pthread/once_atomic.hpp" 2 3 4
>
>namespace boost
>{
>
> struct once_flag;
>
> namespace thread_detail
> {
>
>
> typedef unsigned int atomic_int_type;
># 47 "/usr/include/boost/thread/pthread/once_atomic.hpp" 3 4
> typedef boost::atomic<atomic_int_type> atomic_type;
>
> __attribute__((__visibility__("default"))) bool enter_once_region(once_flag& flag) noexcept;
> __attribute__((__visibility__("default"))) void commit_once_region(once_flag& flag) noexcept;
> __attribute__((__visibility__("default"))) void rollback_once_region(once_flag& flag) noexcept;
> inline atomic_type& get_atomic_storage(once_flag& flag) noexcept;
> }
># 85 "/usr/include/boost/thread/pthread/once_atomic.hpp" 3 4
> struct once_flag
> {
>
>
>
> __attribute__((__may_alias__)) thread_detail::atomic_int_type storage;
> };
>
>
>
> namespace thread_detail
> {
> inline atomic_type& get_atomic_storage(once_flag& flag) noexcept
> {
> return reinterpret_cast< atomic_type& >(flag.storage);
> }
>
> }
># 120 "/usr/include/boost/thread/pthread/once_atomic.hpp" 3 4
> template<typename Function, class ...ArgTypes>
> inline void call_once(once_flag& flag, Function && f, ArgTypes &&... args)
> {
> if (thread_detail::enter_once_region(flag))
> {
> { try
> {
> detail::invoke(
> thread_detail::decay_copy(boost::forward<Function>(f)),
> thread_detail::decay_copy(boost::forward<ArgTypes>(args))...
> ) ;
> }
> catch(...)
> {
> thread_detail::rollback_once_region(flag);
> throw;
> }
> }
> thread_detail::commit_once_region(flag);
> }
> }
># 308 "/usr/include/boost/thread/pthread/once_atomic.hpp" 3 4
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 311 "/usr/include/boost/thread/pthread/once_atomic.hpp" 2 3 4
># 21 "/usr/include/boost/thread/once.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 29 "/usr/include/boost/thread/once.hpp" 2 3 4
>
>namespace boost
>{
>
>
>template<typename Function>
>inline void call_once(Function func,once_flag& flag)
>
> {
> call_once(flag,func);
> }
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 43 "/usr/include/boost/thread/once.hpp" 2 3 4
># 18 "/usr/include/boost/thread.hpp" 2 3 4
># 1 "/usr/include/boost/thread/recursive_mutex.hpp" 1 3 4
># 16 "/usr/include/boost/thread/recursive_mutex.hpp" 3 4
># 1 "/usr/include/boost/thread/pthread/recursive_mutex.hpp" 1 3 4
># 16 "/usr/include/boost/thread/pthread/recursive_mutex.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 17 "/usr/include/boost/thread/pthread/recursive_mutex.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/errno.h" 1 3 4
># 22 "/usr/include/boost/thread/pthread/recursive_mutex.hpp" 2 3 4
># 43 "/usr/include/boost/thread/pthread/recursive_mutex.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 44 "/usr/include/boost/thread/pthread/recursive_mutex.hpp" 2 3 4
>
>namespace boost
>{
> class recursive_mutex
> {
> private:
> pthread_mutex_t m;
>
>
>
>
>
>
> public:
> recursive_mutex(recursive_mutex const&) = delete; recursive_mutex& operator=(recursive_mutex const&) = delete;
> recursive_mutex()
> {
>
> pthread_mutexattr_t attr;
>
> int const init_attr_res=pthread_mutexattr_init(&attr);
> if(init_attr_res)
> {
> boost::throw_exception(thread_resource_error(init_attr_res, "boost:: recursive_mutex constructor failed in pthread_mutexattr_init"));
> }
> int const set_attr_res=pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
> if(set_attr_res)
> {
> ((void)(!pthread_mutexattr_destroy(&attr)));
> boost::throw_exception(thread_resource_error(set_attr_res, "boost:: recursive_mutex constructor failed in pthread_mutexattr_settype"));
> }
>
> int const res=pthread_mutex_init(&m,&attr);
> if(res)
> {
> ((void)(!pthread_mutexattr_destroy(&attr)));
> boost::throw_exception(thread_resource_error(res, "boost:: recursive_mutex constructor failed in pthread_mutex_init"));
> }
> ((void)(!pthread_mutexattr_destroy(&attr)));
># 98 "/usr/include/boost/thread/pthread/recursive_mutex.hpp" 3 4
> }
> ~recursive_mutex()
> {
> ((void)(!pthread_mutex_destroy(&m)));
>
>
>
> }
>
>
> void lock()
> {
> ((void)(!pthread_mutex_lock(&m)));
> }
>
> void unlock()
> {
> ((void)(!pthread_mutex_unlock(&m)));
> }
>
> bool try_lock() noexcept
> {
> int const res=pthread_mutex_trylock(&m);
> ((void)0);
> return !res;
> }
>
> typedef pthread_mutex_t* native_handle_type;
> native_handle_type native_handle()
> {
> return &m;
> }
># 176 "/usr/include/boost/thread/pthread/recursive_mutex.hpp" 3 4
> typedef unique_lock<recursive_mutex> scoped_lock;
> typedef detail::try_lock_wrapper<recursive_mutex> scoped_try_lock;
>
> };
>
> typedef recursive_mutex recursive_try_mutex;
>
> class recursive_timed_mutex
> {
> private:
> pthread_mutex_t m;
>
>
>
>
>
>
> public:
> recursive_timed_mutex(recursive_timed_mutex const&) = delete; recursive_timed_mutex& operator=(recursive_timed_mutex const&) = delete;
> recursive_timed_mutex()
> {
>
> pthread_mutexattr_t attr;
>
> int const init_attr_res=pthread_mutexattr_init(&attr);
> if(init_attr_res)
> {
> boost::throw_exception(thread_resource_error(init_attr_res, "boost:: recursive_timed_mutex constructor failed in pthread_mutexattr_init"));
> }
> int const set_attr_res=pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
> if(set_attr_res)
> {
> boost::throw_exception(thread_resource_error(set_attr_res, "boost:: recursive_timed_mutex constructor failed in pthread_mutexattr_settype"));
> }
>
> int const res=pthread_mutex_init(&m,&attr);
> if(res)
> {
> ((void)(!pthread_mutexattr_destroy(&attr)));
> boost::throw_exception(thread_resource_error(res, "boost:: recursive_timed_mutex constructor failed in pthread_mutex_init"));
> }
> ((void)(!pthread_mutexattr_destroy(&attr)));
># 233 "/usr/include/boost/thread/pthread/recursive_mutex.hpp" 3 4
> }
> ~recursive_timed_mutex()
> {
> ((void)(!pthread_mutex_destroy(&m)));
>
>
>
> }
>
>
> template<typename TimeDuration>
> bool timed_lock(TimeDuration const & relative_time)
> {
> return timed_lock(get_system_time()+relative_time);
> }
>
>
>
> void lock()
> {
> ((void)(!pthread_mutex_lock(&m)));
> }
>
> void unlock()
> {
> ((void)(!pthread_mutex_unlock(&m)));
> }
>
> bool try_lock()
> {
> int const res=pthread_mutex_trylock(&m);
> ((void)0);
> return !res;
> }
> private:
> bool do_try_lock_until(struct timespec const &timeout)
> {
> int const res=pthread_mutex_timedlock(&m,&timeout);
> ((void)0);
> return !res;
> }
>
> public:
># 347 "/usr/include/boost/thread/pthread/recursive_mutex.hpp" 3 4
> bool timed_lock(system_time const & abs_time)
> {
> struct timespec const ts=detail::to_timespec(abs_time);
> return do_try_lock_until(ts);
> }
>
>
> template <class Rep, class Period>
> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
> {
> return try_lock_until(chrono::steady_clock::now() + rel_time);
> }
> template <class Clock, class Duration>
> bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
> {
> using namespace chrono;
> system_clock::time_point s_now = system_clock::now();
> typename Clock::time_point c_now = Clock::now();
> return try_lock_until(s_now + ceil<nanoseconds>(t - c_now));
> }
> template <class Duration>
> bool try_lock_until(const chrono::time_point<chrono::system_clock, Duration>& t)
> {
> using namespace chrono;
> typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
> return try_lock_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
> }
> bool try_lock_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
> {
>
> chrono::nanoseconds d = tp.time_since_epoch();
> timespec ts = boost::detail::to_timespec(d);
> return do_try_lock_until(ts);
> }
>
>
>
> typedef pthread_mutex_t* native_handle_type;
> native_handle_type native_handle()
> {
> return &m;
> }
>
>
> typedef unique_lock<recursive_timed_mutex> scoped_timed_lock;
> typedef detail::try_lock_wrapper<recursive_timed_mutex> scoped_try_lock;
> typedef scoped_timed_lock scoped_lock;
>
> };
>
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 400 "/usr/include/boost/thread/pthread/recursive_mutex.hpp" 2 3 4
># 17 "/usr/include/boost/thread/recursive_mutex.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost
>{
> namespace sync
> {
># 51 "/usr/include/boost/thread/recursive_mutex.hpp" 3 4
> template<>
> struct is_recursive_mutex_sur_parolle<recursive_mutex>
> {
> static const bool value = true;
> };
> template<>
> struct is_recursive_mutex_sur_parolle<recursive_timed_mutex>
> {
> static const bool value = true;
> };
>
> }
>}
># 19 "/usr/include/boost/thread.hpp" 2 3 4
># 1 "/usr/include/boost/thread/tss.hpp" 1 3 4
># 12 "/usr/include/boost/thread/tss.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 13 "/usr/include/boost/thread/tss.hpp" 2 3 4
>
>namespace boost
>{
> namespace detail
> {
> struct tss_cleanup_function
> {
> virtual ~tss_cleanup_function()
> {}
>
> virtual void operator()(void* data)=0;
> };
>
> __attribute__((__visibility__("default"))) void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing);
> __attribute__((__visibility__("default"))) void* get_tss_data(void const* key);
> }
>
> template <typename T>
> class thread_specific_ptr
> {
> private:
> thread_specific_ptr(thread_specific_ptr&);
> thread_specific_ptr& operator=(thread_specific_ptr&);
>
> struct delete_data:
> detail::tss_cleanup_function
> {
> void operator()(void* data)
> {
> delete static_cast<T*>(data);
> }
> };
>
> struct run_custom_cleanup_function:
> detail::tss_cleanup_function
> {
> void (*cleanup_function)(T*);
>
> explicit run_custom_cleanup_function(void (*cleanup_function_)(T*)):
> cleanup_function(cleanup_function_)
> {}
>
> void operator()(void* data)
> {
> cleanup_function(static_cast<T*>(data));
> }
> };
>
>
> boost::shared_ptr<detail::tss_cleanup_function> cleanup;
>
> public:
> typedef T element_type;
>
> thread_specific_ptr():
> cleanup(detail::heap_new<delete_data>(),detail::do_heap_delete<delete_data>())
> {}
> explicit thread_specific_ptr(void (*func_)(T*))
> {
> if(func_)
> {
> cleanup.reset(detail::heap_new<run_custom_cleanup_function>(func_),detail::do_heap_delete<run_custom_cleanup_function>());
> }
> }
> ~thread_specific_ptr()
> {
> detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,true);
> }
>
> T* get() const
> {
> return static_cast<T*>(detail::get_tss_data(this));
> }
> T* operator->() const
> {
> return get();
> }
> T& operator*() const
> {
> return *get();
> }
> T* release()
> {
> T* const temp=get();
> detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,false);
> return temp;
> }
> void reset(T* new_value=0)
> {
> T* const current_value=get();
> if(current_value!=new_value)
> {
> detail::set_tss_data(this,cleanup,new_value,true);
> }
> }
> };
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 112 "/usr/include/boost/thread/tss.hpp" 2 3 4
># 20 "/usr/include/boost/thread.hpp" 2 3 4
>
># 1 "/usr/include/boost/thread/locks.hpp" 1 3 4
># 10 "/usr/include/boost/thread/locks.hpp" 3 4
># 1 "/usr/include/boost/thread/lock_algorithms.hpp" 1 3 4
># 17 "/usr/include/boost/thread/lock_algorithms.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 18 "/usr/include/boost/thread/lock_algorithms.hpp" 2 3 4
>
>namespace boost
>{
> namespace detail
> {
> template <typename MutexType1, typename MutexType2>
> unsigned try_lock_internal(MutexType1& m1, MutexType2& m2)
> {
> boost::unique_lock<MutexType1> l1(m1, boost::try_to_lock);
> if (!l1)
> {
> return 1;
> }
> if (!m2.try_lock())
> {
> return 2;
> }
> l1.release();
> return 0;
> }
>
> template <typename MutexType1, typename MutexType2, typename MutexType3>
> unsigned try_lock_internal(MutexType1& m1, MutexType2& m2, MutexType3& m3)
> {
> boost::unique_lock<MutexType1> l1(m1, boost::try_to_lock);
> if (!l1)
> {
> return 1;
> }
> if (unsigned const failed_lock=try_lock_internal(m2,m3))
> {
> return failed_lock + 1;
> }
> l1.release();
> return 0;
> }
>
> template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4>
> unsigned try_lock_internal(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4)
> {
> boost::unique_lock<MutexType1> l1(m1, boost::try_to_lock);
> if (!l1)
> {
> return 1;
> }
> if (unsigned const failed_lock=try_lock_internal(m2,m3,m4))
> {
> return failed_lock + 1;
> }
> l1.release();
> return 0;
> }
>
> template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4, typename MutexType5>
> unsigned try_lock_internal(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4, MutexType5& m5)
> {
> boost::unique_lock<MutexType1> l1(m1, boost::try_to_lock);
> if (!l1)
> {
> return 1;
> }
> if (unsigned const failed_lock=try_lock_internal(m2,m3,m4,m5))
> {
> return failed_lock + 1;
> }
> l1.release();
> return 0;
> }
>
> template <typename MutexType1, typename MutexType2>
> unsigned lock_helper(MutexType1& m1, MutexType2& m2)
> {
> boost::unique_lock<MutexType1> l1(m1);
> if (!m2.try_lock())
> {
> return 1;
> }
> l1.release();
> return 0;
> }
>
> template <typename MutexType1, typename MutexType2, typename MutexType3>
> unsigned lock_helper(MutexType1& m1, MutexType2& m2, MutexType3& m3)
> {
> boost::unique_lock<MutexType1> l1(m1);
> if (unsigned const failed_lock=try_lock_internal(m2,m3))
> {
> return failed_lock;
> }
> l1.release();
> return 0;
> }
>
> template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4>
> unsigned lock_helper(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4)
> {
> boost::unique_lock<MutexType1> l1(m1);
> if (unsigned const failed_lock=try_lock_internal(m2,m3,m4))
> {
> return failed_lock;
> }
> l1.release();
> return 0;
> }
>
> template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4, typename MutexType5>
> unsigned lock_helper(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4, MutexType5& m5)
> {
> boost::unique_lock<MutexType1> l1(m1);
> if (unsigned const failed_lock=try_lock_internal(m2,m3,m4,m5))
> {
> return failed_lock;
> }
> l1.release();
> return 0;
> }
> }
>
> namespace detail
> {
> template <bool x>
> struct is_mutex_type_wrapper
> {
> };
>
> template <typename MutexType1, typename MutexType2>
> void lock_impl(MutexType1& m1, MutexType2& m2, is_mutex_type_wrapper<true> )
> {
> unsigned const lock_count = 2;
> unsigned lock_first = 0;
> for (;;)
> {
> switch (lock_first)
> {
> case 0:
> lock_first = detail::lock_helper(m1, m2);
> if (!lock_first) return;
> break;
> case 1:
> lock_first = detail::lock_helper(m2, m1);
> if (!lock_first) return;
> lock_first = (lock_first + 1) % lock_count;
> break;
> }
> }
> }
>
> template <typename Iterator>
> void lock_impl(Iterator begin, Iterator end, is_mutex_type_wrapper<false> );
> }
>
> template <typename MutexType1, typename MutexType2>
> void lock(MutexType1& m1, MutexType2& m2)
> {
> detail::lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
> }
>
> template <typename MutexType1, typename MutexType2>
> void lock(const MutexType1& m1, MutexType2& m2)
> {
> detail::lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
> }
>
> template <typename MutexType1, typename MutexType2>
> void lock(MutexType1& m1, const MutexType2& m2)
> {
> detail::lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
> }
>
> template <typename MutexType1, typename MutexType2>
> void lock(const MutexType1& m1, const MutexType2& m2)
> {
> detail::lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
> }
>
> template <typename MutexType1, typename MutexType2, typename MutexType3>
> void lock(MutexType1& m1, MutexType2& m2, MutexType3& m3)
> {
> unsigned const lock_count = 3;
> unsigned lock_first = 0;
> for (;;)
> {
> switch (lock_first)
> {
> case 0:
> lock_first = detail::lock_helper(m1, m2, m3);
> if (!lock_first) return;
> break;
> case 1:
> lock_first = detail::lock_helper(m2, m3, m1);
> if (!lock_first) return;
> lock_first = (lock_first + 1) % lock_count;
> break;
> case 2:
> lock_first = detail::lock_helper(m3, m1, m2);
> if (!lock_first) return;
> lock_first = (lock_first + 2) % lock_count;
> break;
> }
> }
> }
>
> template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4>
> void lock(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4)
> {
> unsigned const lock_count = 4;
> unsigned lock_first = 0;
> for (;;)
> {
> switch (lock_first)
> {
> case 0:
> lock_first = detail::lock_helper(m1, m2, m3, m4);
> if (!lock_first) return;
> break;
> case 1:
> lock_first = detail::lock_helper(m2, m3, m4, m1);
> if (!lock_first) return;
> lock_first = (lock_first + 1) % lock_count;
> break;
> case 2:
> lock_first = detail::lock_helper(m3, m4, m1, m2);
> if (!lock_first) return;
> lock_first = (lock_first + 2) % lock_count;
> break;
> case 3:
> lock_first = detail::lock_helper(m4, m1, m2, m3);
> if (!lock_first) return;
> lock_first = (lock_first + 3) % lock_count;
> break;
> }
> }
> }
>
> template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4, typename MutexType5>
> void lock(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4, MutexType5& m5)
> {
> unsigned const lock_count = 5;
> unsigned lock_first = 0;
> for (;;)
> {
> switch (lock_first)
> {
> case 0:
> lock_first = detail::lock_helper(m1, m2, m3, m4, m5);
> if (!lock_first) return;
> break;
> case 1:
> lock_first = detail::lock_helper(m2, m3, m4, m5, m1);
> if (!lock_first) return;
> lock_first = (lock_first + 1) % lock_count;
> break;
> case 2:
> lock_first = detail::lock_helper(m3, m4, m5, m1, m2);
> if (!lock_first) return;
> lock_first = (lock_first + 2) % lock_count;
> break;
> case 3:
> lock_first = detail::lock_helper(m4, m5, m1, m2, m3);
> if (!lock_first) return;
> lock_first = (lock_first + 3) % lock_count;
> break;
> case 4:
> lock_first = detail::lock_helper(m5, m1, m2, m3, m4);
> if (!lock_first) return;
> lock_first = (lock_first + 4) % lock_count;
> break;
> }
> }
> }
>
> namespace detail
> {
> template <typename Mutex, bool x = is_mutex_type<Mutex>::value>
> struct try_lock_impl_return
> {
> typedef int type;
> };
>
> template <typename Iterator>
> struct try_lock_impl_return<Iterator, false>
> {
> typedef Iterator type;
> };
>
> template <typename MutexType1, typename MutexType2>
> int try_lock_impl(MutexType1& m1, MutexType2& m2, is_mutex_type_wrapper<true> )
> {
> return ((int) detail::try_lock_internal(m1, m2)) - 1;
> }
>
> template <typename Iterator>
> Iterator try_lock_impl(Iterator begin, Iterator end, is_mutex_type_wrapper<false> );
> }
>
> template <typename MutexType1, typename MutexType2>
> typename detail::try_lock_impl_return<MutexType1>::type try_lock(MutexType1& m1, MutexType2& m2)
> {
> return detail::try_lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
> }
>
> template <typename MutexType1, typename MutexType2>
> typename detail::try_lock_impl_return<MutexType1>::type try_lock(const MutexType1& m1, MutexType2& m2)
> {
> return detail::try_lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
> }
>
> template <typename MutexType1, typename MutexType2>
> typename detail::try_lock_impl_return<MutexType1>::type try_lock(MutexType1& m1, const MutexType2& m2)
> {
> return detail::try_lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
> }
>
> template <typename MutexType1, typename MutexType2>
> typename detail::try_lock_impl_return<MutexType1>::type try_lock(const MutexType1& m1, const MutexType2& m2)
> {
> return detail::try_lock_impl(m1, m2, detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
> }
>
> template <typename MutexType1, typename MutexType2, typename MutexType3>
> int try_lock(MutexType1& m1, MutexType2& m2, MutexType3& m3)
> {
> return ((int) detail::try_lock_internal(m1, m2, m3)) - 1;
> }
>
> template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4>
> int try_lock(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4)
> {
> return ((int) detail::try_lock_internal(m1, m2, m3, m4)) - 1;
> }
>
> template <typename MutexType1, typename MutexType2, typename MutexType3, typename MutexType4, typename MutexType5>
> int try_lock(MutexType1& m1, MutexType2& m2, MutexType3& m3, MutexType4& m4, MutexType5& m5)
> {
> return ((int) detail::try_lock_internal(m1, m2, m3, m4, m5)) - 1;
> }
>
> namespace detail
> {
> template <typename Iterator>
> struct range_lock_guard
> {
> Iterator begin;
> Iterator end;
>
> range_lock_guard(Iterator begin_, Iterator end_) :
> begin(begin_), end(end_)
> {
> boost::lock(begin, end);
> }
>
> void release()
> {
> begin = end;
> }
>
> ~range_lock_guard()
> {
> for (; begin != end; ++begin)
> {
> begin->unlock();
> }
> }
> };
>
> template <typename Iterator>
> Iterator try_lock_impl(Iterator begin, Iterator end, is_mutex_type_wrapper<false> )
>
> {
> if (begin == end)
> {
> return end;
> }
> typedef typename std::iterator_traits<Iterator>::value_type lock_type;
> unique_lock<lock_type> guard(*begin, try_to_lock);
>
> if (!guard.owns_lock())
> {
> return begin;
> }
> Iterator const failed = boost::try_lock(++begin, end);
> if (failed == end)
> {
> guard.release();
> }
>
> return failed;
> }
> }
>
> namespace detail
> {
> template <typename Iterator>
> void lock_impl(Iterator begin, Iterator end, is_mutex_type_wrapper<false> )
> {
> typedef typename std::iterator_traits<Iterator>::value_type lock_type;
>
> if (begin == end)
> {
> return;
> }
> bool start_with_begin = true;
> Iterator second = begin;
> ++second;
> Iterator next = second;
>
> for (;;)
> {
> unique_lock<lock_type> begin_lock(*begin, defer_lock);
> if (start_with_begin)
> {
> begin_lock.lock();
> Iterator const failed_lock = boost::try_lock(next, end);
> if (failed_lock == end)
> {
> begin_lock.release();
> return;
> }
> start_with_begin = false;
> next = failed_lock;
> }
> else
> {
> detail::range_lock_guard<Iterator> guard(next, end);
> if (begin_lock.try_lock())
> {
> Iterator const failed_lock = boost::try_lock(second, next);
> if (failed_lock == next)
> {
> begin_lock.release();
> guard.release();
> return;
> }
> start_with_begin = false;
> next = failed_lock;
> }
> else
> {
> start_with_begin = true;
> next = second;
> }
> }
> }
> }
>
> }
>
>}
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 467 "/usr/include/boost/thread/lock_algorithms.hpp" 2 3 4
># 11 "/usr/include/boost/thread/locks.hpp" 2 3 4
># 22 "/usr/include/boost/thread.hpp" 2 3 4
>
># 1 "/usr/include/boost/thread/barrier.hpp" 1 3 4
># 21 "/usr/include/boost/thread/barrier.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 22 "/usr/include/boost/thread/barrier.hpp" 2 3 4
>
>namespace boost
>{
>
> class barrier
> {
> public:
> barrier(barrier const&) = delete; barrier& operator=(barrier const&) = delete;
>
> barrier(unsigned int count)
> : m_threshold(count), m_count(count), m_generation(0)
> {
> if (count == 0)
> boost::throw_exception(thread_exception(system::errc::invalid_argument, "barrier constructor: count cannot be zero."));
> }
>
> bool wait()
> {
> boost::unique_lock<boost::mutex> lock(m_mutex);
> unsigned int gen = m_generation;
>
> if (--m_count == 0)
> {
> m_generation++;
> m_count = m_threshold;
> m_cond.notify_all();
> return true;
> }
>
> while (gen == m_generation)
> m_cond.wait(lock);
> return false;
> }
>
> private:
> mutex m_mutex;
> condition_variable m_cond;
> unsigned int m_threshold;
> unsigned int m_count;
> unsigned int m_generation;
> };
>
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 67 "/usr/include/boost/thread/barrier.hpp" 2 3 4
># 24 "/usr/include/boost/thread.hpp" 2 3 4
># 1 "/usr/include/boost/thread/future.hpp" 1 3 4
># 22 "/usr/include/boost/thread/future.hpp" 3 4
># 1 "/usr/include/boost/thread/detail/async_func.hpp" 1 3 4
># 28 "/usr/include/boost/thread/detail/async_func.hpp" 3 4
># 1 "/usr/include/boost/utility/result_of.hpp" 1 3 4
># 18 "/usr/include/boost/utility/result_of.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/repetition/enum_shifted_params.hpp" 1 3 4
># 19 "/usr/include/boost/utility/result_of.hpp" 2 3 4
># 57 "/usr/include/boost/utility/result_of.hpp" 3 4
>namespace boost {
>
>template<typename F> struct result_of;
>template<typename F> struct tr1_result_of;
>
>
>namespace detail {
>
>template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_result_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper const volatile* , boost::mpl::aux::type_wrapper<typename U::result_type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
>
>template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
># 127 "/usr/include/boost/utility/result_of.hpp" 3 4
>template<typename T>
>struct result_of_always_void
>{
> typedef void type;
>};
>
>template<typename F, typename Enable = void> struct cpp0x_result_of_impl {};
>
>
>
>template<typename F>
>struct result_of_void_impl
>{
> typedef void type;
>};
>
>template<typename R>
>struct result_of_void_impl<R (*)(void)>
>{
> typedef R type;
>};
>
>template<typename R>
>struct result_of_void_impl<R (&)(void)>
>{
> typedef R type;
>};
>
>
>template<typename F, typename FArgs>
>struct result_of_pointer
> : tr1_result_of_impl<typename remove_cv<F>::type, FArgs, false> { };
>
>template<typename F, typename FArgs>
>struct tr1_result_of_impl<F, FArgs, true>
>{
> typedef typename F::result_type type;
>};
>
>template<typename FArgs>
>struct is_function_with_no_args : mpl::false_ {};
>
>template<typename F>
>struct is_function_with_no_args<F(void)> : mpl::true_ {};
>
>template<typename F, typename FArgs>
>struct result_of_nested_result : F::template result<FArgs>
>{};
>
>template<typename F, typename FArgs>
>struct tr1_result_of_impl<F, FArgs, false>
> : mpl::if_<is_function_with_no_args<FArgs>,
> result_of_void_impl<F>,
> result_of_nested_result<F, FArgs> >::type
>{};
>
>}
>
>
># 1 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
># 24 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
># 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
># 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
># 25 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
># 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
># 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
># 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
># 27 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
># 47 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F >
>struct tr1_result_of<F()>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type(),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F(),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F >
>struct result_of<F()>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type(), false
> >
> , detail::cpp0x_result_of_impl<
> F()
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F >
>struct cpp0x_result_of_impl<F(),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> 
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> 
> )
> ) type;
>};
>
>
>
>}
># 48 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0>
>struct tr1_result_of<F( T0)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0>
>struct result_of<F( T0)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0>
>struct cpp0x_result_of_impl<F( T0),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0>
>struct tr1_result_of_impl<R (*)( T0), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0>
>struct tr1_result_of_impl<R (&)( T0), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0>
>struct tr1_result_of_impl<R (T0::*)
> (),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0>
>struct tr1_result_of_impl<R (T0::*)
> ()
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0>
>struct tr1_result_of_impl<R (T0::*)
> ()
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0>
>struct tr1_result_of_impl<R (T0::*)
> ()
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 53 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1>
>struct tr1_result_of<F( T0 , T1)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0 , T1),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0 , typename T1>
>struct result_of<F( T0 , T1)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0 , T1)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1>
>struct cpp0x_result_of_impl<F( T0 , T1),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0 , typename T1>
>struct tr1_result_of_impl<R (*)( T0 , T1), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1>
>struct tr1_result_of_impl<R (&)( T0 , T1), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0 , typename T1>
>struct tr1_result_of_impl<R (T0::*)
> ( T1),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1>
>struct tr1_result_of_impl<R (T0::*)
> ( T1)
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1>
>struct tr1_result_of_impl<R (T0::*)
> ( T1)
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1>
>struct tr1_result_of_impl<R (T0::*)
> ( T1)
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 58 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2>
>struct tr1_result_of<F( T0 , T1 , T2)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0 , T1 , T2),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0 , typename T1 , typename T2>
>struct result_of<F( T0 , T1 , T2)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0 , T1 , T2)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2>
>struct cpp0x_result_of_impl<F( T0 , T1 , T2),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2>
>struct tr1_result_of_impl<R (*)( T0 , T1 , T2), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2>
>struct tr1_result_of_impl<R (&)( T0 , T1 , T2), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2)
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2)
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2)
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 63 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3>
>struct tr1_result_of<F( T0 , T1 , T2 , T3)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0 , T1 , T2 , T3),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3>
>struct result_of<F( T0 , T1 , T2 , T3)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0 , T1 , T2 , T3)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3>
>struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3>
>struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3>
>struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3)
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3)
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3)
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 68 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
>struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0 , T1 , T2 , T3 , T4),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
>struct result_of<F( T0 , T1 , T2 , T3 , T4)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0 , T1 , T2 , T3 , T4)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
>struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
>struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
>struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4)
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4)
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4)
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 73 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
>struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0 , T1 , T2 , T3 , T4 , T5),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
>struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0 , T1 , T2 , T3 , T4 , T5)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
>struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
>struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
>struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5)
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5)
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5)
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 78 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
>struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
>struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
>struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
>struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
>struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6)
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6)
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6)
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 83 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
>struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
>struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
>struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
>struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
>struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7)
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7)
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7)
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 88 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
>struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
>struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
>struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
>struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
>struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 93 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
>struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
>struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
>struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
>struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
>struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 98 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
>struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
>struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
>struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
>struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
>struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 103 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
>struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
>struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
>struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
>struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
>struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 108 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
>struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
>struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
>struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
>struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
>struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 113 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
>struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
>struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
>struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >() , boost::declval<T13 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >() , boost::declval<T13 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
>struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
>struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 118 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
>struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
>struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
>struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >() , boost::declval<T13 >() , boost::declval<T14 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >() , boost::declval<T13 >() , boost::declval<T14 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
>struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
>struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 123 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
># 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
>struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)>
> : mpl::if_<
> mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
> , boost::detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15),
> (boost::detail::has_result_type<F>::value)>
> , boost::detail::tr1_result_of_impl<
> F,
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15),
> (boost::detail::has_result_type<F>::value)> >::type { };
>
>
>
>
>
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
>struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)>
> : mpl::if_<
> is_member_function_pointer<F>
> , detail::tr1_result_of_impl<
> typename remove_cv<F>::type,
> typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15), false
> >
> , detail::cpp0x_result_of_impl<
> F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)
> >
> >::type
>{};
>
>namespace detail {
># 124 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
>struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15),
> typename result_of_always_void<decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >() , boost::declval<T13 >() , boost::declval<T14 >() , boost::declval<T15 >()
> )
> )>::type> {
> typedef decltype(
> boost::declval<F>()(
> boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >() , boost::declval<T13 >() , boost::declval<T14 >() , boost::declval<T15 >()
> )
> ) type;
>};
>
>
>
>}
># 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
>namespace detail {
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
>struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15), FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
>struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15), FArgs, false>
>{
> typedef R type;
>};
>
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15),
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)
> const,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)
> volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
>struct tr1_result_of_impl<R (T0::*)
> ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)
> const volatile,
> FArgs, false>
>{
> typedef R type;
>};
>
>
>}
># 128 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
># 187 "/usr/include/boost/utility/result_of.hpp" 2 3 4
>
>
>
>
>
>}
># 29 "/usr/include/boost/thread/detail/async_func.hpp" 2 3 4
># 40 "/usr/include/boost/thread/detail/async_func.hpp" 3 4
>namespace boost
>{
> namespace detail
> {
>
>
>
>
> template <class Fp, class ... Args>
> class async_func
> {
> std::tuple<Fp, Args...> f_;
>
> public:
> async_func(async_func const&) = delete; async_func& operator=(async_func const&) = delete;
>
> typedef typename result_of<Fp(Args...)>::type result_type;
>
> __attribute__((__visibility__("default")))
> explicit async_func(Fp && f, Args &&... args)
> : f_(boost::move(f), boost::move(args)...)
> {}
>
> __attribute__((__visibility__("default")))
> async_func(async_func && f) : f_(boost::move(f.f_))
> {}
>
> result_type operator()()
> {
> typedef typename make_tuple_indices<1+sizeof...(Args), 1>::type Index;
> return execute(Index());
> }
> private:
> template <size_t ...Indices>
> result_type
> execute(tuple_indices<Indices...>)
> {
> return invoke(boost::move(std::get<0>(f_)), boost::move(std::get<Indices>(f_))...);
> }
> };
># 568 "/usr/include/boost/thread/detail/async_func.hpp" 3 4
> }
>}
># 23 "/usr/include/boost/thread/future.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/exception_ptr.hpp" 1 3 4
># 9 "/usr/include/boost/exception_ptr.hpp" 3 4
># 1 "/usr/include/boost/exception/detail/exception_ptr.hpp" 1 3 4
># 9 "/usr/include/boost/exception/detail/exception_ptr.hpp" 3 4
> 
># 10 "/usr/include/boost/exception/detail/exception_ptr.hpp" 3
># 20 "/usr/include/boost/exception/detail/exception_ptr.hpp" 3
># 1 "/usr/include/boost/exception/info.hpp" 1 3 4
># 9 "/usr/include/boost/exception/info.hpp" 3 4
> 
># 10 "/usr/include/boost/exception/info.hpp" 3
>
>
>
>
>
>
># 1 "/usr/include/boost/exception/to_string_stub.hpp" 1 3 4
># 9 "/usr/include/boost/exception/to_string_stub.hpp" 3 4
> 
># 10 "/usr/include/boost/exception/to_string_stub.hpp" 3
>
>
>
>
>
># 1 "/usr/include/boost/exception/to_string.hpp" 1 3 4
># 9 "/usr/include/boost/exception/to_string.hpp" 3 4
> 
># 10 "/usr/include/boost/exception/to_string.hpp" 3
>
>
>
>
>
>
># 1 "/usr/include/boost/exception/detail/is_output_streamable.hpp" 1 3 4
># 9 "/usr/include/boost/exception/detail/is_output_streamable.hpp" 3 4
> 
># 10 "/usr/include/boost/exception/detail/is_output_streamable.hpp" 3
>
>
>
>
>
>
>
>namespace
>boost
> {
> namespace
> to_string_detail
> {
> struct
> partial_ordering_helper1
> {
> template <class CharT,class Traits>
> partial_ordering_helper1( std::basic_ostream<CharT,Traits> & );
> };
>
> struct
> partial_ordering_helper2
> {
> template <class T>
> partial_ordering_helper2( T const & );
> };
>
> char operator<<( partial_ordering_helper1, partial_ordering_helper2 );
>
> template <class T,class CharT,class Traits>
> struct
> is_output_streamable_impl
> {
> static std::basic_ostream<CharT,Traits> & f();
> static T const & g();
> enum e { value=1!=(sizeof(f()<<g())) };
> };
> }
>
> template <class T, class CharT=char, class Traits=std::char_traits<CharT> >
> struct
> is_output_streamable
> {
> enum e { value=to_string_detail::is_output_streamable_impl<T,CharT,Traits>::value };
> };
> }
># 17 "/usr/include/boost/exception/to_string.hpp" 2 3
>
>
>namespace
>boost
> {
> template <class T,class U>
> std::string to_string( std::pair<T,U> const & );
> std::string to_string( std::exception const & );
>
> namespace
> to_string_detail
> {
> template <class T>
> typename disable_if<is_output_streamable<T>,char>::type to_string( T const & );
> using boost::to_string;
>
> template <class,bool IsOutputStreamable>
> struct has_to_string_impl;
>
> template <class T>
> struct
> has_to_string_impl<T,true>
> {
> enum e { value=1 };
> };
>
> template <class T>
> struct
> has_to_string_impl<T,false>
> {
> static T const & f();
> enum e { value=1!=sizeof(to_string(f())) };
> };
> }
>
> template <class T>
> inline
> typename enable_if<is_output_streamable<T>,std::string>::type
> to_string( T const & x )
> {
> std::ostringstream out;
> out << x;
> return out.str();
> }
>
> template <class T>
> struct
> has_to_string
> {
> enum e { value=to_string_detail::has_to_string_impl<T,is_output_streamable<T>::value>::value };
> };
>
> template <class T,class U>
> inline
> std::string
> to_string( std::pair<T,U> const & x )
> {
> return std::string("(") + to_string(x.first) + ',' + to_string(x.second) + ')';
> }
>
> inline
> std::string
> to_string( std::exception const & x )
> {
> return x.what();
> }
> }
># 16 "/usr/include/boost/exception/to_string_stub.hpp" 2 3
># 1 "/usr/include/boost/exception/detail/object_hex_dump.hpp" 1 3 4
># 9 "/usr/include/boost/exception/detail/object_hex_dump.hpp" 3 4
> 
># 10 "/usr/include/boost/exception/detail/object_hex_dump.hpp" 3
>
>
>
>
>
># 1 "/usr/include/boost/exception/detail/type_info.hpp" 1 3 4
># 9 "/usr/include/boost/exception/detail/type_info.hpp" 3 4
> 
># 10 "/usr/include/boost/exception/detail/type_info.hpp" 3
># 19 "/usr/include/boost/exception/detail/type_info.hpp" 3
># 1 "/usr/include/boost/units/detail/utility.hpp" 1 3 4
># 14 "/usr/include/boost/units/detail/utility.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstdlib" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstdlib" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstdlib" 3
># 15 "/usr/include/boost/units/detail/utility.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/c++/4.8.2/cxxabi.h" 1 3 4
># 44 "/usr/include/c++/4.8.2/cxxabi.h" 3 4
> 
># 45 "/usr/include/c++/4.8.2/cxxabi.h" 3
>
>#pragma GCC visibility push(default)
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 49 "/usr/include/c++/4.8.2/cxxabi.h" 2 3
>
># 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/cxxabi_tweaks.h" 1 3
># 34 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/cxxabi_tweaks.h" 3
>namespace __cxxabiv1
>{
> extern "C"
> {
># 46 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/cxxabi_tweaks.h" 3
> __extension__ typedef int __guard __attribute__((mode (__DI__)));
>
>
> typedef void __cxa_vec_ctor_return_type;
>
>
> typedef void __cxa_cdtor_return_type;
>
>
> }
>}
># 51 "/usr/include/c++/4.8.2/cxxabi.h" 2 3
>
>
>
>
>
>
>
>namespace __cxxabiv1
>{
> extern "C"
> {
>
>
> typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(void *);
>
>
> void*
> __cxa_vec_new(size_t __element_count, size_t __element_size,
> size_t __padding_size, __cxa_cdtor_type __constructor,
> __cxa_cdtor_type __destructor);
>
> void*
> __cxa_vec_new2(size_t __element_count, size_t __element_size,
> size_t __padding_size, __cxa_cdtor_type __constructor,
> __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
> void (*__dealloc) (void*));
>
> void*
> __cxa_vec_new3(size_t __element_count, size_t __element_size,
> size_t __padding_size, __cxa_cdtor_type __constructor,
> __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
> void (*__dealloc) (void*, size_t));
>
>
> __cxa_vec_ctor_return_type
> __cxa_vec_ctor(void* __array_address, size_t __element_count,
> size_t __element_size, __cxa_cdtor_type __constructor,
> __cxa_cdtor_type __destructor);
>
> __cxa_vec_ctor_return_type
> __cxa_vec_cctor(void* __dest_array, void* __src_array,
> size_t __element_count, size_t __element_size,
> __cxa_cdtor_return_type (*__constructor) (void*, void*),
> __cxa_cdtor_type __destructor);
>
>
> void
> __cxa_vec_dtor(void* __array_address, size_t __element_count,
> size_t __element_size, __cxa_cdtor_type __destructor);
>
> void
> __cxa_vec_cleanup(void* __array_address, size_t __element_count, size_t __s,
> __cxa_cdtor_type __destructor) noexcept;
>
>
> void
> __cxa_vec_delete(void* __array_address, size_t __element_size,
> size_t __padding_size, __cxa_cdtor_type __destructor);
>
> void
> __cxa_vec_delete2(void* __array_address, size_t __element_size,
> size_t __padding_size, __cxa_cdtor_type __destructor,
> void (*__dealloc) (void*));
>
> void
> __cxa_vec_delete3(void* __array_address, size_t __element_size,
> size_t __padding_size, __cxa_cdtor_type __destructor,
> void (*__dealloc) (void*, size_t));
>
> int
> __cxa_guard_acquire(__guard*);
>
> void
> __cxa_guard_release(__guard*) noexcept;
>
> void
> __cxa_guard_abort(__guard*) noexcept;
>
>
> int
> __cxa_atexit(void (*)(void*), void*, void*) noexcept;
>
> int
> __cxa_finalize(void*);
>
>
> int
> __cxa_thread_atexit(void (*)(void*), void*, void *) noexcept;
>
>
> void
> __cxa_pure_virtual(void) __attribute__ ((__noreturn__));
>
> void
> __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
>
>
> void
> __cxa_bad_cast() __attribute__((__noreturn__));
>
> void
> __cxa_bad_typeid() __attribute__((__noreturn__));
># 195 "/usr/include/c++/4.8.2/cxxabi.h" 3
> char*
> __cxa_demangle(const char* __mangled_name, char* __output_buffer,
> size_t* __length, int* __status);
>
>
> }
>}
>
>
>
>
>
>
>namespace __cxxabiv1
>{
>
> class __fundamental_type_info : public std::type_info
> {
> public:
> explicit
> __fundamental_type_info(const char* __n) : std::type_info(__n) { }
>
> virtual
> ~__fundamental_type_info();
> };
>
>
> class __array_type_info : public std::type_info
> {
> public:
> explicit
> __array_type_info(const char* __n) : std::type_info(__n) { }
>
> virtual
> ~__array_type_info();
> };
>
>
> class __function_type_info : public std::type_info
> {
> public:
> explicit
> __function_type_info(const char* __n) : std::type_info(__n) { }
>
> virtual
> ~__function_type_info();
>
> protected:
>
> virtual bool
> __is_function_p() const;
> };
>
>
> class __enum_type_info : public std::type_info
> {
> public:
> explicit
> __enum_type_info(const char* __n) : std::type_info(__n) { }
>
> virtual
> ~__enum_type_info();
> };
>
>
> class __pbase_type_info : public std::type_info
> {
> public:
> unsigned int __flags;
> const std::type_info* __pointee;
>
> explicit
> __pbase_type_info(const char* __n, int __quals,
> const std::type_info* __type)
> : std::type_info(__n), __flags(__quals), __pointee(__type)
> { }
>
> virtual
> ~__pbase_type_info();
>
>
> enum __masks
> {
> __const_mask = 0x1,
> __volatile_mask = 0x2,
> __restrict_mask = 0x4,
> __incomplete_mask = 0x8,
> __incomplete_class_mask = 0x10
> };
>
> protected:
> __pbase_type_info(const __pbase_type_info&);
>
> __pbase_type_info&
> operator=(const __pbase_type_info&);
>
>
> virtual bool
> __do_catch(const std::type_info* __thr_type, void** __thr_obj,
> unsigned int __outer) const;
>
> inline virtual bool
> __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
> unsigned __outer) const;
> };
>
>
> class __pointer_type_info : public __pbase_type_info
> {
> public:
> explicit
> __pointer_type_info(const char* __n, int __quals,
> const std::type_info* __type)
> : __pbase_type_info (__n, __quals, __type) { }
>
>
> virtual
> ~__pointer_type_info();
>
> protected:
>
> virtual bool
> __is_pointer_p() const;
>
> virtual bool
> __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
> unsigned __outer) const;
> };
>
> class __class_type_info;
>
>
> class __pointer_to_member_type_info : public __pbase_type_info
> {
> public:
> __class_type_info* __context;
>
> explicit
> __pointer_to_member_type_info(const char* __n, int __quals,
> const std::type_info* __type,
> __class_type_info* __klass)
> : __pbase_type_info(__n, __quals, __type), __context(__klass) { }
>
> virtual
> ~__pointer_to_member_type_info();
>
> protected:
> __pointer_to_member_type_info(const __pointer_to_member_type_info&);
>
> __pointer_to_member_type_info&
> operator=(const __pointer_to_member_type_info&);
>
>
> virtual bool
> __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
> unsigned __outer) const;
> };
>
>
> class __base_class_type_info
> {
> public:
> const __class_type_info* __base_type;
>
>
>
> long __offset_flags;
>
>
> enum __offset_flags_masks
> {
> __virtual_mask = 0x1,
> __public_mask = 0x2,
> __hwm_bit = 2,
> __offset_shift = 8
> };
>
>
> bool
> __is_virtual_p() const
> { return __offset_flags & __virtual_mask; }
>
> bool
> __is_public_p() const
> { return __offset_flags & __public_mask; }
>
> ptrdiff_t
> __offset() const
> {
>
>
>
> return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
> }
> };
>
>
> class __class_type_info : public std::type_info
> {
> public:
> explicit
> __class_type_info (const char *__n) : type_info(__n) { }
>
> virtual
> ~__class_type_info ();
>
>
>
>
>
>
> enum __sub_kind
> {
>
> __unknown = 0,
>
>
>
> __not_contained,
>
>
> __contained_ambig,
>
>
> __contained_virtual_mask = __base_class_type_info::__virtual_mask,
>
>
> __contained_public_mask = __base_class_type_info::__public_mask,
>
>
> __contained_mask = 1 << __base_class_type_info::__hwm_bit,
>
> __contained_private = __contained_mask,
> __contained_public = __contained_mask | __contained_public_mask
> };
>
> struct __upcast_result;
> struct __dyncast_result;
>
> protected:
>
> virtual bool
> __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;
>
> virtual bool
> __do_catch(const type_info* __thr_type, void** __thr_obj,
> unsigned __outer) const;
>
> public:
>
>
> virtual bool
> __do_upcast(const __class_type_info* __dst, const void* __obj,
> __upcast_result& __restrict __result) const;
>
>
>
>
>
>
>
> inline __sub_kind
> __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
> const __class_type_info* __src_type,
> const void* __src_ptr) const;
># 468 "/usr/include/c++/4.8.2/cxxabi.h" 3
> virtual bool
> __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
> const __class_type_info* __dst_type, const void* __obj_ptr,
> const __class_type_info* __src_type, const void* __src_ptr,
> __dyncast_result& __result) const;
>
>
>
>
>
> virtual __sub_kind
> __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
> const __class_type_info* __src_type,
> const void* __src_ptr) const;
> };
>
>
> class __si_class_type_info : public __class_type_info
> {
> public:
> const __class_type_info* __base_type;
>
> explicit
> __si_class_type_info(const char *__n, const __class_type_info *__base)
> : __class_type_info(__n), __base_type(__base) { }
>
> virtual
> ~__si_class_type_info();
>
> protected:
> __si_class_type_info(const __si_class_type_info&);
>
> __si_class_type_info&
> operator=(const __si_class_type_info&);
>
>
> virtual bool
> __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
> const __class_type_info* __dst_type, const void* __obj_ptr,
> const __class_type_info* __src_type, const void* __src_ptr,
> __dyncast_result& __result) const;
>
> virtual __sub_kind
> __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
> const __class_type_info* __src_type,
> const void* __sub_ptr) const;
>
> virtual bool
> __do_upcast(const __class_type_info*__dst, const void*__obj,
> __upcast_result& __restrict __result) const;
> };
>
>
> class __vmi_class_type_info : public __class_type_info
> {
> public:
> unsigned int __flags;
> unsigned int __base_count;
>
>
>
>
> __base_class_type_info __base_info[1];
>
> explicit
> __vmi_class_type_info(const char* __n, int ___flags)
> : __class_type_info(__n), __flags(___flags), __base_count(0) { }
>
> virtual
> ~__vmi_class_type_info();
>
>
> enum __flags_masks
> {
> __non_diamond_repeat_mask = 0x1,
> __diamond_shaped_mask = 0x2,
> __flags_unknown_mask = 0x10
> };
>
> protected:
>
> virtual bool
> __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
> const __class_type_info* __dst_type, const void* __obj_ptr,
> const __class_type_info* __src_type, const void* __src_ptr,
> __dyncast_result& __result) const;
>
> virtual __sub_kind
> __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
> const __class_type_info* __src_type,
> const void* __src_ptr) const;
>
> virtual bool
> __do_upcast(const __class_type_info* __dst, const void* __obj,
> __upcast_result& __restrict __result) const;
> };
>
>
> struct __cxa_exception;
> struct __cxa_refcounted_exception;
> struct __cxa_dependent_exception;
> struct __cxa_eh_globals;
>
> extern "C"
> {
># 581 "/usr/include/c++/4.8.2/cxxabi.h" 3
> void*
> __dynamic_cast(const void* __src_ptr,
> const __class_type_info* __src_type,
> const __class_type_info* __dst_type,
> ptrdiff_t __src2dst);
># 594 "/usr/include/c++/4.8.2/cxxabi.h" 3
> __cxa_eh_globals*
> __cxa_get_globals() noexcept __attribute__ ((__const__));
>
> __cxa_eh_globals*
> __cxa_get_globals_fast() noexcept __attribute__ ((__const__));
>
>
> void*
> __cxa_allocate_exception(size_t) noexcept;
>
>
> void
> __cxa_free_exception(void*) noexcept;
>
>
> void
> __cxa_throw(void*, std::type_info*, void ( *) (void *))
> __attribute__((__noreturn__));
>
>
> void*
> __cxa_get_exception_ptr(void*) noexcept __attribute__ ((__pure__));
>
> void*
> __cxa_begin_catch(void*) noexcept;
>
> void
> __cxa_end_catch();
>
> void
> __cxa_rethrow() __attribute__((__noreturn__));
>
>
>
> std::type_info*
> __cxa_current_exception_type() noexcept __attribute__ ((__pure__));
>
>
>
>
> __cxa_dependent_exception*
> __cxa_allocate_dependent_exception() noexcept;
>
>
> void
> __cxa_free_dependent_exception(__cxa_dependent_exception*) noexcept;
>
> }
>
>
>
> class __foreign_exception
> {
> virtual ~__foreign_exception() throw();
> virtual void __pure_dummy() = 0;
> };
>
>}
># 673 "/usr/include/c++/4.8.2/cxxabi.h" 3
>namespace abi = __cxxabiv1;
>
>namespace __gnu_cxx
>{
># 689 "/usr/include/c++/4.8.2/cxxabi.h" 3
> class recursive_init_error: public std::exception
> {
> public:
> recursive_init_error() throw() { }
> virtual ~recursive_init_error() throw ();
> };
>}
>
>
>#pragma GCC visibility pop
># 21 "/usr/include/boost/units/detail/utility.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/algorithm/string/replace.hpp" 1 3 4
># 14 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
># 1 "/usr/include/boost/algorithm/string/config.hpp" 1 3 4
># 15 "/usr/include/boost/algorithm/string/replace.hpp" 2 3 4
>
># 1 "/usr/include/boost/range/iterator_range.hpp" 1 3 4
># 13 "/usr/include/boost/range/iterator_range.hpp" 3 4
># 1 "/usr/include/boost/range/iterator_range_core.hpp" 1 3 4
># 21 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 22 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/range/functions.hpp" 1 3 4
># 18 "/usr/include/boost/range/functions.hpp" 3 4
># 1 "/usr/include/boost/range/begin.hpp" 1 3 4
># 18 "/usr/include/boost/range/begin.hpp" 3 4
># 1 "/usr/include/boost/range/config.hpp" 1 3 4
># 19 "/usr/include/boost/range/begin.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/range/iterator.hpp" 1 3 4
># 19 "/usr/include/boost/range/iterator.hpp" 3 4
># 1 "/usr/include/boost/range/mutable_iterator.hpp" 1 3 4
># 24 "/usr/include/boost/range/mutable_iterator.hpp" 3 4
># 1 "/usr/include/boost/range/detail/extract_optional_type.hpp" 1 3 4
># 30 "/usr/include/boost/range/detail/extract_optional_type.hpp" 3 4
>namespace boost {
> namespace range_detail {
> template< typename T > struct exists { typedef void type; };
> }
>}
># 25 "/usr/include/boost/range/mutable_iterator.hpp" 2 3 4
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 27 "/usr/include/boost/range/mutable_iterator.hpp" 2 3 4
>
>
>namespace boost
>{
>
>
>
>
> namespace range_detail {
> template< typename C, typename Enable=void > struct extract_iterator {}; template< typename C > struct extract_iterator< C , typename boost::range_detail::exists< typename C::iterator >::type > { typedef typename C::iterator type; };
> }
>
> template< typename C >
> struct range_mutable_iterator : range_detail::extract_iterator<C>
> {};
>
>
>
>
>
> template< typename Iterator >
> struct range_mutable_iterator< std::pair<Iterator,Iterator> >
> {
> typedef Iterator type;
> };
>
>
>
>
>
> template< typename T, std::size_t sz >
> struct range_mutable_iterator< T[sz] >
> {
> typedef T* type;
> };
>
>}
># 20 "/usr/include/boost/range/iterator.hpp" 2 3 4
># 1 "/usr/include/boost/range/const_iterator.hpp" 1 3 4
># 26 "/usr/include/boost/range/const_iterator.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 27 "/usr/include/boost/range/const_iterator.hpp" 2 3 4
>
>
>namespace boost
>{
>
>
>
>
> namespace range_detail {
> template< typename C, typename Enable=void > struct extract_const_iterator {}; template< typename C > struct extract_const_iterator< C , typename boost::range_detail::exists< typename C::const_iterator >::type > { typedef typename C::const_iterator type; };
> }
>
> template< typename C >
> struct range_const_iterator : range_detail::extract_const_iterator<C>
> {};
>
>
>
>
>
> template< typename Iterator >
> struct range_const_iterator< std::pair<Iterator,Iterator> >
> {
> typedef Iterator type;
> };
>
>
>
>
>
> template< typename T, std::size_t sz >
> struct range_const_iterator< T[sz] >
> {
> typedef const T* type;
> };
>
>}
># 21 "/usr/include/boost/range/iterator.hpp" 2 3 4
>
>
>
>
>namespace boost
>{
># 50 "/usr/include/boost/range/iterator.hpp" 3 4
> template< typename C >
> struct range_iterator
> {
>
>
>
>
>
>
>
> typedef typename
> mpl::eval_if_c< is_const<C>::value,
> range_const_iterator< typename remove_const<C>::type >,
> range_mutable_iterator<C> >::type type;
>
>
> };
>
>}
># 25 "/usr/include/boost/range/begin.hpp" 2 3 4
>
>namespace boost
>{
>
>
>
>
>namespace range_detail
>{
>
>
>
>
>
>
> template< typename C >
> inline typename range_iterator<C>::type
> range_begin( C& c )
> {
>
>
>
>
>
> return c.begin();
> }
>
>
>
>
>
> template< typename Iterator >
> inline Iterator range_begin( const std::pair<Iterator,Iterator>& p )
> {
> return p.first;
> }
>
> template< typename Iterator >
> inline Iterator range_begin( std::pair<Iterator,Iterator>& p )
> {
> return p.first;
> }
># 75 "/usr/include/boost/range/begin.hpp" 3 4
> template< typename T, std::size_t sz >
> inline const T* range_begin( const T (&a)[sz] )
> {
> return a;
> }
>
> template< typename T, std::size_t sz >
> inline T* range_begin( T (&a)[sz] )
> {
> return a;
> }
>
>
>
>
>
>}
>
>
>
>
>
>namespace range_adl_barrier
>{
>
>template< class T >
>inline typename range_iterator<T>::type begin( T& r )
>{
>
>
>
> using namespace range_detail;
>
> return range_begin( r );
>}
>
>template< class T >
>inline typename range_iterator<const T>::type begin( const T& r )
>{
>
>
>
> using namespace range_detail;
>
> return range_begin( r );
>}
>
> }
>}
>
>
>
>namespace boost
>{
> namespace range_adl_barrier
> {
> template< class T >
> inline typename range_iterator<const T>::type
> const_begin( const T& r )
> {
> return boost::range_adl_barrier::begin( r );
> }
> }
>
> using namespace range_adl_barrier;
>}
># 19 "/usr/include/boost/range/functions.hpp" 2 3 4
># 1 "/usr/include/boost/range/end.hpp" 1 3 4
># 24 "/usr/include/boost/range/end.hpp" 3 4
># 1 "/usr/include/boost/range/detail/implementation_help.hpp" 1 3 4
># 15 "/usr/include/boost/range/detail/implementation_help.hpp" 3 4
># 1 "/usr/include/boost/range/detail/common.hpp" 1 3 4
># 19 "/usr/include/boost/range/detail/common.hpp" 3 4
># 1 "/usr/include/boost/range/detail/sfinae.hpp" 1 3 4
># 20 "/usr/include/boost/range/detail/sfinae.hpp" 3 4
>namespace boost
>{
> namespace range_detail
> {
> using type_traits::yes_type;
> using type_traits::no_type;
>
>
>
>
>
> yes_type is_string_impl( const char* const );
> yes_type is_string_impl( const wchar_t* const );
> no_type is_string_impl( ... );
>
> template< std::size_t sz >
> yes_type is_char_array_impl( char (&boost_range_array)[sz] );
> template< std::size_t sz >
> yes_type is_char_array_impl( const char (&boost_range_array)[sz] );
> no_type is_char_array_impl( ... );
>
> template< std::size_t sz >
> yes_type is_wchar_t_array_impl( wchar_t (&boost_range_array)[sz] );
> template< std::size_t sz >
> yes_type is_wchar_t_array_impl( const wchar_t (&boost_range_array)[sz] );
> no_type is_wchar_t_array_impl( ... );
>
> yes_type is_char_ptr_impl( char* const );
> no_type is_char_ptr_impl( ... );
>
> yes_type is_const_char_ptr_impl( const char* const );
> no_type is_const_char_ptr_impl( ... );
>
> yes_type is_wchar_t_ptr_impl( wchar_t* const );
> no_type is_wchar_t_ptr_impl( ... );
>
> yes_type is_const_wchar_t_ptr_impl( const wchar_t* const );
> no_type is_const_wchar_t_ptr_impl( ... );
>
>
>
>
>
> template< typename Iterator >
> yes_type is_pair_impl( const std::pair<Iterator,Iterator>* );
> no_type is_pair_impl( ... );
>
>
>
>
>
> struct char_or_wchar_t_array_tag {};
>
> }
>
>}
># 20 "/usr/include/boost/range/detail/common.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 25 "/usr/include/boost/range/detail/common.hpp" 2 3 4
>
>
>
>
>
>namespace boost
>{
> namespace range_detail
> {
># 47 "/usr/include/boost/range/detail/common.hpp" 3 4
> typedef mpl::int_<1>::type std_container_;
> typedef mpl::int_<2>::type std_pair_;
> typedef mpl::int_<3>::type const_std_pair_;
> typedef mpl::int_<4>::type array_;
> typedef mpl::int_<5>::type const_array_;
> typedef mpl::int_<6>::type char_array_;
> typedef mpl::int_<7>::type wchar_t_array_;
> typedef mpl::int_<8>::type char_ptr_;
> typedef mpl::int_<9>::type const_char_ptr_;
> typedef mpl::int_<10>::type wchar_t_ptr_;
> typedef mpl::int_<11>::type const_wchar_t_ptr_;
> typedef mpl::int_<12>::type string_;
>
> template< typename C >
> struct range_helper
> {
> static C* c;
> static C ptr;
>
> static const bool is_pair_ = sizeof( boost::range_detail::is_pair_impl( c ) ) == sizeof( yes_type );
> static const bool is_char_ptr_ = sizeof( boost::range_detail::is_char_ptr_impl( ptr ) ) == sizeof( yes_type );
> static const bool is_const_char_ptr_ = sizeof( boost::range_detail::is_const_char_ptr_impl( ptr ) ) == sizeof( yes_type );
> static const bool is_wchar_t_ptr_ = sizeof( boost::range_detail::is_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type );
> static const bool is_const_wchar_t_ptr_ = sizeof( boost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type );
> static const bool is_char_array_ = sizeof( boost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type );
> static const bool is_wchar_t_array_ = sizeof( boost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type );
> static const bool is_string_ = (boost::type_traits::ice_or<is_const_char_ptr_, is_const_wchar_t_ptr_>::value );
> static const bool is_array_ = boost::is_array<C>::value;
>
> };
>
> template< typename C >
> class range
> {
> typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_pair_,
> boost::range_detail::std_pair_,
> void >::type pair_t;
> typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_array_,
> boost::range_detail::array_,
> pair_t >::type array_t;
> typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_string_,
> boost::range_detail::string_,
> array_t >::type string_t;
> typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_char_ptr_,
> boost::range_detail::const_char_ptr_,
> string_t >::type const_char_ptr_t;
> typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_ptr_,
> boost::range_detail::char_ptr_,
> const_char_ptr_t >::type char_ptr_t;
> typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_wchar_t_ptr_,
> boost::range_detail::const_wchar_t_ptr_,
> char_ptr_t >::type const_wchar_ptr_t;
> typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_ptr_,
> boost::range_detail::wchar_t_ptr_,
> const_wchar_ptr_t >::type wchar_ptr_t;
> typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_array_,
> boost::range_detail::wchar_t_array_,
> wchar_ptr_t >::type wchar_array_t;
> typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_array_,
> boost::range_detail::char_array_,
> wchar_array_t >::type char_array_t;
> public:
> typedef typename boost::mpl::if_c< ::boost::is_void<char_array_t>::value,
> boost::range_detail::std_container_,
> char_array_t >::type type;
> };
> }
>}
># 16 "/usr/include/boost/range/detail/implementation_help.hpp" 2 3 4
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 18 "/usr/include/boost/range/detail/implementation_help.hpp" 2 3 4
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 22 "/usr/include/boost/range/detail/implementation_help.hpp" 2 3 4
>
>
>namespace boost
>{
> namespace range_detail
> {
> template <typename T>
> inline void boost_range_silence_warning( const T& ) { }
>
>
>
>
>
> inline const char* str_end( const char* s, const char* )
> {
> return s + strlen( s );
> }
>
>
> inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
> {
> return s + wcslen( s );
> }
># 56 "/usr/include/boost/range/detail/implementation_help.hpp" 3 4
> template< class Char >
> inline Char* str_end( Char* s )
> {
> return const_cast<Char*>( str_end( s, s ) );
> }
>
> template< class T, std::size_t sz >
> inline T* array_end( T (&boost_range_array)[sz] )
> {
> return boost_range_array + sz;
> }
>
> template< class T, std::size_t sz >
> inline const T* array_end( const T (&boost_range_array)[sz] )
> {
> return boost_range_array + sz;
> }
>
>
>
>
>
> template< class Char >
> inline std::size_t str_size( const Char* const& s )
> {
> return str_end( s ) - s;
> }
>
> template< class T, std::size_t sz >
> inline std::size_t array_size( T (&boost_range_array)[sz] )
> {
> boost_range_silence_warning( boost_range_array );
> return sz;
> }
>
> template< class T, std::size_t sz >
> inline std::size_t array_size( const T (&boost_range_array)[sz] )
> {
> boost_range_silence_warning( boost_range_array );
> return sz;
> }
>
> }
>
>}
># 25 "/usr/include/boost/range/end.hpp" 2 3 4
>
>
>
>namespace boost
>{
>
>
>
>
>namespace range_detail
>{
>
>
>
>
>
> template< typename C >
> inline typename range_iterator<C>::type
> range_end( C& c )
> {
>
>
>
>
>
> return c.end();
> }
>
>
>
>
>
> template< typename Iterator >
> inline Iterator range_end( const std::pair<Iterator,Iterator>& p )
> {
> return p.second;
> }
>
> template< typename Iterator >
> inline Iterator range_end( std::pair<Iterator,Iterator>& p )
> {
> return p.second;
> }
>
>
>
>
>
> template< typename T, std::size_t sz >
> inline const T* range_end( const T (&a)[sz] )
> {
> return range_detail::array_end<T,sz>( a );
> }
>
> template< typename T, std::size_t sz >
> inline T* range_end( T (&a)[sz] )
> {
> return range_detail::array_end<T,sz>( a );
> }
>
>
>
>
>}
>
>
>namespace range_adl_barrier
>{
>
>template< class T >
>inline typename range_iterator<T>::type end( T& r )
>{
>
>
>
> using namespace range_detail;
>
> return range_end( r );
>}
>
>template< class T >
>inline typename range_iterator<const T>::type end( const T& r )
>{
>
>
>
> using namespace range_detail;
>
> return range_end( r );
>}
>
> }
>}
>
>
>
>namespace boost
>{
> namespace range_adl_barrier
> {
> template< class T >
> inline typename range_iterator<const T>::type
> const_end( const T& r )
> {
> return boost::range_adl_barrier::end( r );
> }
> }
> using namespace range_adl_barrier;
>}
># 20 "/usr/include/boost/range/functions.hpp" 2 3 4
># 1 "/usr/include/boost/range/size.hpp" 1 3 4
># 21 "/usr/include/boost/range/size.hpp" 3 4
># 1 "/usr/include/boost/range/size_type.hpp" 1 3 4
># 19 "/usr/include/boost/range/size_type.hpp" 3 4
># 1 "/usr/include/boost/range/difference_type.hpp" 1 3 4
># 22 "/usr/include/boost/range/difference_type.hpp" 3 4
>namespace boost
>{
> template< class T >
> struct range_difference : iterator_difference< typename range_iterator<T>::type >
> { };
>}
># 20 "/usr/include/boost/range/size_type.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 28 "/usr/include/boost/range/size_type.hpp" 2 3 4
>
>
>namespace boost
>{
> namespace detail
> {
>
>
>
>
>
> template<typename T>
> class has_size_type
> {
> typedef char no_type;
> struct yes_type { char dummy[2]; };
>
> template<typename C>
> static yes_type test(typename C::size_type x);
>
> template<typename C, typename Arg>
> static no_type test(Arg x);
>
> public:
> static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
> };
>
> template<typename C, typename Enabler=void>
> struct range_size
> {
> typedef typename make_unsigned<
> typename range_difference<C>::type
> >::type type;
> };
>
> template<typename C>
> struct range_size<
> C,
> typename enable_if<has_size_type<C>, void>::type
> >
> {
> typedef typename C::size_type type;
> };
>
> }
>
> template< class T >
> struct range_size :
> detail::range_size<T>
> { };
>
> template< class T >
> struct range_size<const T >
> : detail::range_size<T>
> { };
>
>}
># 22 "/usr/include/boost/range/size.hpp" 2 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 23 "/usr/include/boost/range/size.hpp" 2 3 4
>
>namespace boost
>{
> namespace range_detail
> {
> template<class SinglePassRange>
> inline typename range_size<const SinglePassRange>::type
> range_calculate_size(const SinglePassRange& rng)
> {
> ((void)0)
> ;
> return boost::end(rng) - boost::begin(rng);
> }
> }
>
> template<class SinglePassRange>
> inline typename range_size<const SinglePassRange>::type
> size(const SinglePassRange& rng)
> {
>
>
>
> using namespace range_detail;
>
> return range_calculate_size(rng);
> }
>
>}
># 21 "/usr/include/boost/range/functions.hpp" 2 3 4
># 1 "/usr/include/boost/range/distance.hpp" 1 3 4
># 22 "/usr/include/boost/range/distance.hpp" 3 4
>namespace boost
>{
>
> template< class T >
> inline typename range_difference<T>::type
> distance( const T& r )
> {
> return std::distance( boost::begin( r ), boost::end( r ) );
> }
>
>}
># 22 "/usr/include/boost/range/functions.hpp" 2 3 4
># 1 "/usr/include/boost/range/empty.hpp" 1 3 4
># 22 "/usr/include/boost/range/empty.hpp" 3 4
>namespace boost
>{
>
> template< class T >
> inline bool empty( const T& r )
> {
> return boost::begin( r ) == boost::end( r );
> }
>
>}
># 23 "/usr/include/boost/range/functions.hpp" 2 3 4
># 1 "/usr/include/boost/range/rbegin.hpp" 1 3 4
># 19 "/usr/include/boost/range/rbegin.hpp" 3 4
># 1 "/usr/include/boost/range/reverse_iterator.hpp" 1 3 4
># 23 "/usr/include/boost/range/reverse_iterator.hpp" 3 4
>namespace boost
>{
>
>
>
>
> template< typename C >
> struct range_reverse_iterator
> {
> typedef reverse_iterator<
> typename range_iterator<C>::type > type;
> };
>
>
>}
># 20 "/usr/include/boost/range/rbegin.hpp" 2 3 4
>
>namespace boost
>{
># 35 "/usr/include/boost/range/rbegin.hpp" 3 4
>template< class C >
>inline typename range_reverse_iterator<C>::type
>rbegin( C& c )
>{
> typedef typename range_reverse_iterator<C>::type
> iter_type;
> return iter_type( boost::end( c ) );
>}
>
>template< class C >
>inline typename range_reverse_iterator<const C>::type
>rbegin( const C& c )
>{
> typedef typename range_reverse_iterator<const C>::type
> iter_type;
> return iter_type( boost::end( c ) );
>}
>
>
>
>template< class T >
>inline typename range_reverse_iterator<const T>::type
>const_rbegin( const T& r )
>{
> return boost::rbegin( r );
>}
>
>}
># 24 "/usr/include/boost/range/functions.hpp" 2 3 4
># 1 "/usr/include/boost/range/rend.hpp" 1 3 4
># 21 "/usr/include/boost/range/rend.hpp" 3 4
>namespace boost
>{
># 35 "/usr/include/boost/range/rend.hpp" 3 4
>template< class C >
>inline typename range_reverse_iterator<C>::type
>rend( C& c )
>{
> typedef typename range_reverse_iterator<C>::type
> iter_type;
> return iter_type( boost::begin( c ) );
>}
>
>template< class C >
>inline typename range_reverse_iterator<const C>::type
>rend( const C& c )
>{
> typedef typename range_reverse_iterator<const C>::type
> iter_type;
> return iter_type( boost::begin( c ) );
>}
>
>
>
>template< class T >
>inline typename range_reverse_iterator<const T>::type
>const_rend( const T& r )
>{
> return boost::rend( r );
>}
>
>}
># 25 "/usr/include/boost/range/functions.hpp" 2 3 4
># 29 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/range/algorithm/equal.hpp" 1 3 4
># 14 "/usr/include/boost/range/algorithm/equal.hpp" 3 4
># 1 "/usr/include/boost/range/concepts.hpp" 1 3 4
># 24 "/usr/include/boost/range/concepts.hpp" 3 4
># 1 "/usr/include/boost/range/value_type.hpp" 1 3 4
># 27 "/usr/include/boost/range/value_type.hpp" 3 4
>namespace boost
>{
> template< class T >
> struct range_value : iterator_value< typename range_iterator<T>::type >
> { };
>}
># 25 "/usr/include/boost/range/concepts.hpp" 2 3 4
># 1 "/usr/include/boost/range/detail/misc_concept.hpp" 1 3 4
># 13 "/usr/include/boost/range/detail/misc_concept.hpp" 3 4
>namespace boost
>{
> namespace range_detail
> {
> template<typename T1, typename T2>
> class SameTypeConcept
> {
> public:
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SameTypeConcept>)>::failed> boost_concept_check21 __attribute__((unused)); ~SameTypeConcept()
> {
> same_type(a,b);
> }
> private:
> template<typename T> void same_type(T,T) {}
> T1 a;
> T2 b;
> };
> }
>}
># 26 "/usr/include/boost/range/concepts.hpp" 2 3 4
># 59 "/usr/include/boost/range/concepts.hpp" 3 4
>namespace boost {
>
> namespace range_detail {
># 112 "/usr/include/boost/range/concepts.hpp" 3 4
> template<class Iterator>
> struct IncrementableIteratorConcept : CopyConstructible<Iterator>
> {
>
> typedef typename iterator_traversal<Iterator>::type traversal_category;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Convertible< traversal_category, incrementable_traversal_tag >)>::failed> boost_concept_check122 __attribute__((unused))
>
>
>
> ;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<IncrementableIteratorConcept>)>::failed> boost_concept_check124 __attribute__((unused)); ~IncrementableIteratorConcept()
> {
> ++i;
> (void)i++;
> }
> private:
> Iterator i;
>
> };
>
> template<class Iterator>
> struct SinglePassIteratorConcept
> : IncrementableIteratorConcept<Iterator>
> , EqualityComparable<Iterator>
> {
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Convertible< typename SinglePassIteratorConcept::traversal_category, single_pass_traversal_tag >)>::failed> boost_concept_check144 __attribute__((unused))
>
>
>
> ;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SinglePassIteratorConcept>)>::failed> boost_concept_check146 __attribute__((unused)); ~SinglePassIteratorConcept()
> {
> Iterator i2(++i);
> boost::ignore_unused_variable_warning(i2);
>
>
>
>
>
> (void)(i++);
>
> typename boost::detail::iterator_traits<Iterator>::reference r1(*i);
> boost::ignore_unused_variable_warning(r1);
>
> typename boost::detail::iterator_traits<Iterator>::reference r2(*(++i));
> boost::ignore_unused_variable_warning(r2);
> }
> private:
> Iterator i;
>
> };
>
> template<class Iterator>
> struct ForwardIteratorConcept
> : SinglePassIteratorConcept<Iterator>
> , DefaultConstructible<Iterator>
> {
>
> typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
>
> enum { mpl_assertion_in_line_176 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_integral<difference_type>))0, 1 ) ) ) };
> enum { mpl_assert_rel_value177 = (std::numeric_limits<difference_type>::is_signed == true) }; enum { mpl_assertion_in_line_177 = sizeof( boost::mpl::assertion_failed<mpl_assert_rel_value177>( (boost::mpl::failed ************ ( boost::mpl::assert_relation< boost::mpl::assert_::relations( sizeof( boost::mpl::assert_::arg == boost::mpl::assert_::arg ) ) , std::numeric_limits<difference_type>::is_signed , true >::************)) 0 ) ) };
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Convertible< typename ForwardIteratorConcept::traversal_category, forward_traversal_tag >)>::failed> boost_concept_check183 __attribute__((unused))
>
>
>
> ;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ForwardIteratorConcept>)>::failed> boost_concept_check185 __attribute__((unused)); ~ForwardIteratorConcept()
> {
>
>
>
>
> Iterator i2(i++);
> boost::ignore_unused_variable_warning(i2);
> typename boost::detail::iterator_traits<Iterator>::reference r(*(i++));
> boost::ignore_unused_variable_warning(r);
> }
> private:
> Iterator i;
>
> };
>
> template<class Iterator>
> struct BidirectionalIteratorConcept
> : ForwardIteratorConcept<Iterator>
> {
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Convertible< typename BidirectionalIteratorConcept::traversal_category, bidirectional_traversal_tag >)>::failed> boost_concept_check210 __attribute__((unused))
>
>
>
> ;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BidirectionalIteratorConcept>)>::failed> boost_concept_check212 __attribute__((unused)); ~BidirectionalIteratorConcept()
> {
> --i;
> (void)i--;
> }
> private:
> Iterator i;
>
> };
>
> template<class Iterator>
> struct RandomAccessIteratorConcept
> : BidirectionalIteratorConcept<Iterator>
> {
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Convertible< typename RandomAccessIteratorConcept::traversal_category, random_access_traversal_tag >)>::failed> boost_concept_check231 __attribute__((unused))
>
>
>
> ;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<RandomAccessIteratorConcept>)>::failed> boost_concept_check233 __attribute__((unused)); ~RandomAccessIteratorConcept()
> {
> i += n;
> i = i + n;
> i = n + i;
> i -= n;
> i = i - n;
> n = i - j;
> }
> private:
> typename RandomAccessIteratorConcept::difference_type n;
> Iterator i;
> Iterator j;
>
> };
>
> }
>
>
> template<class T>
> struct SinglePassRangeConcept
> {
>
> typedef typename range_iterator<T const>::type const_iterator;
> typedef typename range_iterator<T>::type iterator;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::SinglePassIteratorConcept<iterator>)>::failed> boost_concept_check259 __attribute__((unused));
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::SinglePassIteratorConcept<const_iterator>)>::failed> boost_concept_check260 __attribute__((unused));
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SinglePassRangeConcept>)>::failed> boost_concept_check262 __attribute__((unused)); ~SinglePassRangeConcept()
> {
>
>
>
> iterator i1 = boost::begin(*m_range);
> iterator i2 = boost::end(*m_range);
>
> ignore_unused_variable_warning(i1);
> ignore_unused_variable_warning(i2);
>
> const_constraints(*m_range);
> }
>
> private:
> void const_constraints(const T& const_range)
> {
> const_iterator ci1 = boost::begin(const_range);
> const_iterator ci2 = boost::end(const_range);
>
> ignore_unused_variable_warning(ci1);
> ignore_unused_variable_warning(ci2);
> }
>
>
>
>
>
> T* m_range;
>
> };
>
>
> template<class T>
> struct ForwardRangeConcept : SinglePassRangeConcept<T>
> {
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::ForwardIteratorConcept<typename ForwardRangeConcept::iterator>)>::failed> boost_concept_check299 __attribute__((unused));
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::ForwardIteratorConcept<typename ForwardRangeConcept::const_iterator>)>::failed> boost_concept_check300 __attribute__((unused));
>
> };
>
> template<class Range>
> struct WriteableRangeConcept
> {
>
> typedef typename range_iterator<Range>::type iterator;
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<WriteableRangeConcept>)>::failed> boost_concept_check310 __attribute__((unused)); ~WriteableRangeConcept()
> {
> *i = v;
> }
> private:
> iterator i;
> typename range_value<Range>::type v;
>
> };
>
>
> template<class T>
> struct WriteableForwardRangeConcept
> : ForwardRangeConcept<T>
> , WriteableRangeConcept<T>
> {
> };
>
>
> template<class T>
> struct BidirectionalRangeConcept : ForwardRangeConcept<T>
> {
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::BidirectionalIteratorConcept<typename BidirectionalRangeConcept::iterator>)>::failed> boost_concept_check333 __attribute__((unused));
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::BidirectionalIteratorConcept<typename BidirectionalRangeConcept::const_iterator>)>::failed> boost_concept_check334 __attribute__((unused));
>
> };
>
>
> template<class T>
> struct WriteableBidirectionalRangeConcept
> : BidirectionalRangeConcept<T>
> , WriteableRangeConcept<T>
> {
> };
>
>
> template<class T>
> struct RandomAccessRangeConcept : BidirectionalRangeConcept<T>
> {
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::RandomAccessIteratorConcept<typename RandomAccessRangeConcept::iterator>)>::failed> boost_concept_check351 __attribute__((unused));
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::RandomAccessIteratorConcept<typename RandomAccessRangeConcept::const_iterator>)>::failed> boost_concept_check352 __attribute__((unused));
>
> };
>
>
> template<class T>
> struct WriteableRandomAccessRangeConcept
> : RandomAccessRangeConcept<T>
> , WriteableRangeConcept<T>
> {
> };
>
>}
># 15 "/usr/include/boost/range/algorithm/equal.hpp" 2 3 4
>
>
>namespace boost
>{
> namespace range_detail
> {
>
>
> template< class SinglePassTraversalReadableIterator1,
> class SinglePassTraversalReadableIterator2,
> class IteratorCategoryTag1,
> class IteratorCategoryTag2 >
> inline bool equal_impl( SinglePassTraversalReadableIterator1 first1,
> SinglePassTraversalReadableIterator1 last1,
> SinglePassTraversalReadableIterator2 first2,
> SinglePassTraversalReadableIterator2 last2,
> IteratorCategoryTag1,
> IteratorCategoryTag2 )
> {
> while (true)
> {
>
>
>
> if (first1 == last1)
> return first2 == last2;
>
>
>
>
> if (first2 == last2)
> return false;
>
>
> if (*first1 != *first2)
> break;
>
> ++first1;
> ++first2;
> }
>
>
>
> return false;
> }
>
> template< class SinglePassTraversalReadableIterator1,
> class SinglePassTraversalReadableIterator2,
> class IteratorCategoryTag1,
> class IteratorCategoryTag2,
> class BinaryPredicate >
> inline bool equal_impl( SinglePassTraversalReadableIterator1 first1,
> SinglePassTraversalReadableIterator1 last1,
> SinglePassTraversalReadableIterator2 first2,
> SinglePassTraversalReadableIterator2 last2,
> BinaryPredicate pred,
> IteratorCategoryTag1,
> IteratorCategoryTag2 )
> {
> while (true)
> {
>
>
>
> if (first1 == last1)
> return first2 == last2;
>
>
>
>
> if (first2 == last2)
> return false;
>
>
> if (!pred(*first1, *first2))
> break;
>
> ++first1;
> ++first2;
> }
>
>
>
> return false;
> }
>
>
>
> template< class RandomAccessTraversalReadableIterator1,
> class RandomAccessTraversalReadableIterator2 >
> inline bool equal_impl( RandomAccessTraversalReadableIterator1 first1,
> RandomAccessTraversalReadableIterator1 last1,
> RandomAccessTraversalReadableIterator2 first2,
> RandomAccessTraversalReadableIterator2 last2,
> std::random_access_iterator_tag,
> std::random_access_iterator_tag )
> {
> return ((last1 - first1) == (last2 - first2))
> && std::equal(first1, last1, first2);
> }
>
> template< class RandomAccessTraversalReadableIterator1,
> class RandomAccessTraversalReadableIterator2,
> class BinaryPredicate >
> inline bool equal_impl( RandomAccessTraversalReadableIterator1 first1,
> RandomAccessTraversalReadableIterator1 last1,
> RandomAccessTraversalReadableIterator2 first2,
> RandomAccessTraversalReadableIterator2 last2,
> BinaryPredicate pred )
> {
> return ((last1 - first1) == (last2 - first2))
> && std::equal(first1, last1, first2, pred);
> }
>
> template< class SinglePassTraversalReadableIterator1,
> class SinglePassTraversalReadableIterator2 >
> inline bool equal( SinglePassTraversalReadableIterator1 first1,
> SinglePassTraversalReadableIterator1 last1,
> SinglePassTraversalReadableIterator2 first2,
> SinglePassTraversalReadableIterator2 last2 )
> {
> typename std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1;
> typename std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2;
>
> return equal_impl(first1, last1, first2, last2, tag1, tag2);
> }
>
> template< class SinglePassTraversalReadableIterator1,
> class SinglePassTraversalReadableIterator2,
> class BinaryPredicate >
> inline bool equal( SinglePassTraversalReadableIterator1 first1,
> SinglePassTraversalReadableIterator1 last1,
> SinglePassTraversalReadableIterator2 first2,
> SinglePassTraversalReadableIterator2 last2,
> BinaryPredicate pred )
> {
> typename std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1;
> typename std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2;
>
> return equal_impl(first1, last1, first2, last2, pred, tag1, tag2);
> }
>
> }
>
> namespace range
> {
># 169 "/usr/include/boost/range/algorithm/equal.hpp" 3 4
> template< class SinglePassRange1, class SinglePassRange2 >
> inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 )
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange1> )>::failed> boost_concept_check172 __attribute__((unused));
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange2> )>::failed> boost_concept_check173 __attribute__((unused));
>
> return ::boost::range_detail::equal(
> ::boost::begin(rng1), ::boost::end(rng1),
> ::boost::begin(rng2), ::boost::end(rng2) );
> }
>
>
> template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
> inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
> BinaryPredicate pred )
> {
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange1> )>::failed> boost_concept_check185 __attribute__((unused));
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange2> )>::failed> boost_concept_check186 __attribute__((unused));
>
> return ::boost::range_detail::equal(
> ::boost::begin(rng1), ::boost::end(rng1),
> ::boost::begin(rng2), ::boost::end(rng2),
> pred);
> }
>
> }
> using ::boost::range::equal;
>}
># 32 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4
># 1 "/usr/include/boost/range/detail/safe_bool.hpp" 1 3 4
># 16 "/usr/include/boost/range/detail/safe_bool.hpp" 3 4
>namespace boost
>{
> namespace range_detail
> {
>
>template<class DataMemberPtr>
>class safe_bool
>{
>public:
> typedef safe_bool this_type;
># 56 "/usr/include/boost/range/detail/safe_bool.hpp" 3 4
> typedef DataMemberPtr unspecified_bool_type;
> static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr p)
> {
> return x ? p : 0;
> }
>
>private:
> safe_bool();
> safe_bool(const safe_bool&);
> void operator=(const safe_bool&);
> ~safe_bool();
>};
>
> }
>}
># 33 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4
>
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 37 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4
># 45 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
>namespace boost
>{
> namespace iterator_range_detail
> {
>
>
>
>
> template<class IteratorT>
> struct iterator_range_impl {
> template< class ForwardRange >
> static IteratorT adl_begin( ForwardRange& r )
> {
> return static_cast<IteratorT>( boost::begin( r ) );
> }
>
> template< class ForwardRange >
> static IteratorT adl_end( ForwardRange& r )
> {
> return static_cast<IteratorT>( boost::end( r ) );
> }
> };
>
> template< class Left, class Right >
> inline bool less_than( const Left& l, const Right& r )
> {
> return std::lexicographical_compare( boost::begin(l),
> boost::end(l),
> boost::begin(r),
> boost::end(r) );
> }
>
> template< class Left, class Right >
> inline bool greater_than( const Left& l, const Right& r )
> {
> return less_than(r,l);
> }
>
> template< class Left, class Right >
> inline bool less_or_equal_than( const Left& l, const Right& r )
> {
> return !iterator_range_detail::less_than(r,l);
> }
>
> template< class Left, class Right >
> inline bool greater_or_equal_than( const Left& l, const Right& r )
> {
> return !iterator_range_detail::less_than(l,r);
> }
>
>
>
> template< class Left, class Right >
> inline bool equal(const Left& l, const Right& r)
> {
> return boost::equal(l, r);
> }
>
> struct range_tag { };
> struct const_range_tag { };
> }
># 126 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
> template<class IteratorT>
> class iterator_range
> {
> typedef range_detail::safe_bool< IteratorT iterator_range<IteratorT>::* > safe_bool_t;
> protected:
>
> typedef iterator_range_detail::iterator_range_impl<IteratorT> impl;
> public:
>
> typedef iterator_range<IteratorT> type;
> typedef typename safe_bool_t::unspecified_bool_type unspecified_bool_type;
>
>
>
> typedef typename
> iterator_value<IteratorT>::type value_type;
>
>
> typedef typename
> iterator_difference<IteratorT>::type difference_type;
>
>
> typedef std::size_t size_type;
>
>
> typedef iterator_range<IteratorT> this_type;
>
>
>
>
>
>
> typedef typename
> iterator_reference<IteratorT>::type reference;
>
>
>
>
>
>
> typedef IteratorT const_iterator;
>
> typedef IteratorT iterator;
>
> private:
> typedef typename
> boost::mpl::if_< boost::mpl::or_< boost::is_abstract< value_type >,
> boost::is_array< value_type > >,
> reference, value_type >::type abstract_value_type;
>
> public:
> iterator_range() : m_Begin( iterator() ), m_End( iterator() )
> { }
>
>
> template< class Iterator >
> iterator_range( Iterator Begin, Iterator End ) :
> m_Begin(Begin), m_End(End)
> {}
>
>
> template< class Range >
> iterator_range( const Range& r ) :
> m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
> {}
>
>
> template< class Range >
> iterator_range( Range& r ) :
> m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
> {}
>
>
> template< class Range >
> iterator_range( const Range& r, iterator_range_detail::const_range_tag ) :
> m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
> {}
>
>
> template< class Range >
> iterator_range( Range& r, iterator_range_detail::range_tag ) :
> m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
> {}
>
>
> this_type& operator=( const this_type& r )
> {
> m_Begin = r.begin();
> m_End = r.end();
> return *this;
> }
>
>
> template< class Iterator >
> iterator_range& operator=( const iterator_range<Iterator>& r )
> {
> m_Begin = r.begin();
> m_End = r.end();
> return *this;
> }
>
> template< class ForwardRange >
> iterator_range& operator=( ForwardRange& r )
> {
> m_Begin = impl::adl_begin( r );
> m_End = impl::adl_end( r );
> return *this;
> }
>
> template< class ForwardRange >
> iterator_range& operator=( const ForwardRange& r )
> {
> m_Begin = impl::adl_begin( r );
> m_End = impl::adl_end( r );
> return *this;
> }
>
> IteratorT begin() const
> {
> return m_Begin;
> }
>
> IteratorT end() const
> {
> return m_End;
> }
>
> difference_type size() const
> {
> return m_End - m_Begin;
> }
>
> bool empty() const
> {
> return m_Begin == m_End;
> }
>
> operator unspecified_bool_type() const
> {
> return safe_bool_t::to_unspecified_bool(m_Begin != m_End, &iterator_range::m_Begin);
> }
>
> bool operator!() const
> {
> return empty();
> }
>
> bool equal( const iterator_range& r ) const
> {
> return m_Begin == r.m_Begin && m_End == r.m_End;
> }
># 313 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
> public:
> reference front() const
> {
> ((void)0);
> return *m_Begin;
> }
>
> reference back() const
> {
> ((void)0);
> IteratorT last( m_End );
> return *--last;
> }
>
>
> void pop_front()
> {
> ((void)0);
> ++m_Begin;
> }
>
>
> void pop_back()
> {
> ((void)0);
> --m_End;
> }
>
> reference operator[]( difference_type at ) const
> {
> ((void)0);
> return m_Begin[at];
> }
>
>
>
>
>
>
> abstract_value_type operator()( difference_type at ) const
> {
> ((void)0);
> return m_Begin[at];
> }
>
> iterator_range& advance_begin( difference_type n )
> {
> std::advance( m_Begin, n );
> return *this;
> }
>
> iterator_range& advance_end( difference_type n )
> {
> std::advance( m_End, n );
> return *this;
> }
>
> private:
>
> IteratorT m_Begin;
> IteratorT m_End;
>
> protected:
>
>
>
>
> typedef iterator_range iterator_range_;
> };
>
>
>
>
>
>
>
> template< class IteratorT, class ForwardRange >
> inline bool operator==( const ForwardRange& l,
> const iterator_range<IteratorT>& r )
> {
> return boost::equal( l, r );
> }
>
> template< class IteratorT, class ForwardRange >
> inline bool operator!=( const ForwardRange& l,
> const iterator_range<IteratorT>& r )
> {
> return !boost::equal( l, r );
> }
>
> template< class IteratorT, class ForwardRange >
> inline bool operator<( const ForwardRange& l,
> const iterator_range<IteratorT>& r )
> {
> return iterator_range_detail::less_than( l, r );
> }
>
> template< class IteratorT, class ForwardRange >
> inline bool operator<=( const ForwardRange& l,
> const iterator_range<IteratorT>& r )
> {
> return iterator_range_detail::less_or_equal_than( l, r );
> }
>
> template< class IteratorT, class ForwardRange >
> inline bool operator>( const ForwardRange& l,
> const iterator_range<IteratorT>& r )
> {
> return iterator_range_detail::greater_than( l, r );
> }
>
> template< class IteratorT, class ForwardRange >
> inline bool operator>=( const ForwardRange& l,
> const iterator_range<IteratorT>& r )
> {
> return iterator_range_detail::greater_or_equal_than( l, r );
> }
>
>
>
> template< class Iterator1T, class Iterator2T >
> inline bool operator==( const iterator_range<Iterator1T>& l,
> const iterator_range<Iterator2T>& r )
> {
> return boost::equal( l, r );
> }
>
> template< class IteratorT, class ForwardRange >
> inline bool operator==( const iterator_range<IteratorT>& l,
> const ForwardRange& r )
> {
> return boost::equal( l, r );
> }
>
>
> template< class Iterator1T, class Iterator2T >
> inline bool operator!=( const iterator_range<Iterator1T>& l,
> const iterator_range<Iterator2T>& r )
> {
> return !boost::equal( l, r );
> }
>
> template< class IteratorT, class ForwardRange >
> inline bool operator!=( const iterator_range<IteratorT>& l,
> const ForwardRange& r )
> {
> return !boost::equal( l, r );
> }
>
>
> template< class Iterator1T, class Iterator2T >
> inline bool operator<( const iterator_range<Iterator1T>& l,
> const iterator_range<Iterator2T>& r )
> {
> return iterator_range_detail::less_than( l, r );
> }
>
> template< class IteratorT, class ForwardRange >
> inline bool operator<( const iterator_range<IteratorT>& l,
> const ForwardRange& r )
> {
> return iterator_range_detail::less_than( l, r );
> }
>
> template< class Iterator1T, class Iterator2T >
> inline bool operator<=( const iterator_range<Iterator1T>& l,
> const iterator_range<Iterator2T>& r )
> {
> return iterator_range_detail::less_or_equal_than( l, r );
> }
>
> template< class IteratorT, class ForwardRange >
> inline bool operator<=( const iterator_range<IteratorT>& l,
> const ForwardRange& r )
> {
> return iterator_range_detail::less_or_equal_than( l, r );
> }
>
> template< class Iterator1T, class Iterator2T >
> inline bool operator>( const iterator_range<Iterator1T>& l,
> const iterator_range<Iterator2T>& r )
> {
> return iterator_range_detail::greater_than( l, r );
> }
>
> template< class IteratorT, class ForwardRange >
> inline bool operator>( const iterator_range<IteratorT>& l,
> const ForwardRange& r )
> {
> return iterator_range_detail::greater_than( l, r );
> }
>
> template< class Iterator1T, class Iterator2T >
> inline bool operator>=( const iterator_range<Iterator1T>& l,
> const iterator_range<Iterator2T>& r )
> {
> return iterator_range_detail::greater_or_equal_than( l, r );
> }
>
> template< class IteratorT, class ForwardRange >
> inline bool operator>=( const iterator_range<IteratorT>& l,
> const ForwardRange& r )
> {
> return iterator_range_detail::greater_or_equal_than( l, r );
> }
># 531 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
> template< typename IteratorT >
> inline iterator_range< IteratorT >
> make_iterator_range( IteratorT Begin, IteratorT End )
> {
> return iterator_range<IteratorT>( Begin, End );
> }
># 554 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
> template< class ForwardRange >
> inline iterator_range< typename range_iterator<ForwardRange>::type >
> make_iterator_range( ForwardRange& r )
> {
> return iterator_range< typename range_iterator<ForwardRange>::type >
> ( r, iterator_range_detail::range_tag() );
> }
>
> template< class ForwardRange >
> inline iterator_range< typename range_iterator<const ForwardRange>::type >
> make_iterator_range( const ForwardRange& r )
> {
> return iterator_range< typename range_iterator<const ForwardRange>::type >
> ( r, iterator_range_detail::const_range_tag() );
> }
>
>
>
> namespace iterator_range_detail
> {
> template< class Range >
> inline iterator_range< typename range_iterator<Range>::type >
> make_range_impl( Range& r,
> typename range_difference<Range>::type advance_begin,
> typename range_difference<Range>::type advance_end )
> {
>
>
>
>
>
>
>
> typename range_iterator<Range>::type
> new_begin = boost::begin( r ),
> new_end = boost::end( r );
> std::advance( new_begin, advance_begin );
> std::advance( new_end, advance_end );
> return make_iterator_range( new_begin, new_end );
> }
> }
># 610 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
> template< class Range >
> inline iterator_range< typename range_iterator<Range>::type >
> make_iterator_range( Range& r,
> typename range_difference<Range>::type advance_begin,
> typename range_difference<Range>::type advance_end )
> {
>
> return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
> }
>
> template< class Range >
> inline iterator_range< typename range_iterator<const Range>::type >
> make_iterator_range( const Range& r,
> typename range_difference<Range>::type advance_begin,
> typename range_difference<Range>::type advance_end )
> {
>
> return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
> }
># 640 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
> template< typename SeqT, typename Range >
> inline SeqT copy_range( const Range& r )
> {
> return SeqT( boost::begin( r ), boost::end( r ) );
> }
>
>}
># 14 "/usr/include/boost/range/iterator_range.hpp" 2 3 4
># 1 "/usr/include/boost/range/iterator_range_io.hpp" 1 3 4
># 41 "/usr/include/boost/range/iterator_range_io.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 42 "/usr/include/boost/range/iterator_range_io.hpp" 2 3 4
>
>namespace boost
>{
># 54 "/usr/include/boost/range/iterator_range_io.hpp" 3 4
> template< typename IteratorT, typename Elem, typename Traits >
> inline std::basic_ostream<Elem,Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& Os,
> const iterator_range<IteratorT>& r )
> {
> std::copy( r.begin(), r.end(),
> std::ostream_iterator< typename
> iterator_value<IteratorT>::type,
> Elem, Traits>(Os) );
> return Os;
> }
># 85 "/usr/include/boost/range/iterator_range_io.hpp" 3 4
>}
># 15 "/usr/include/boost/range/iterator_range.hpp" 2 3 4
># 17 "/usr/include/boost/algorithm/string/replace.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/algorithm/string/find_format.hpp" 1 3 4
># 20 "/usr/include/boost/algorithm/string/find_format.hpp" 3 4
># 1 "/usr/include/boost/range/as_literal.hpp" 1 3 4
># 23 "/usr/include/boost/range/as_literal.hpp" 3 4
># 1 "/usr/include/boost/range/detail/str_types.hpp" 1 3 4
># 17 "/usr/include/boost/range/detail/str_types.hpp" 3 4
>namespace boost
>{
> template< class T >
> struct range_mutable_iterator<T*>
> {
> typedef T* type;
> };
>
> template< class T >
> struct range_const_iterator<T*>
> {
> typedef const T* type;
> };
>
> template< class T >
> struct range_size<T*>
> {
> typedef std::size_t type;
> };
>}
># 24 "/usr/include/boost/range/as_literal.hpp" 2 3 4
>
>
>
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 28 "/usr/include/boost/range/as_literal.hpp" 2 3 4
>
># 1 "/usr/include/c++/4.8.2/cwchar" 1 3 4
># 39 "/usr/include/c++/4.8.2/cwchar" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cwchar" 3
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 45 "/usr/include/c++/4.8.2/cwchar" 2 3
># 30 "/usr/include/boost/range/as_literal.hpp" 2 3 4
>
>
>namespace boost
>{
> namespace range_detail
> {
> inline std::size_t length( const char* s )
> {
> return strlen( s );
> }
>
>
> inline std::size_t length( const wchar_t* s )
> {
> return wcslen( s );
> }
># 54 "/usr/include/boost/range/as_literal.hpp" 3 4
> inline bool is_char_ptr( char* )
> {
> return true;
> }
>
> inline bool is_char_ptr( const char* )
> {
> return true;
> }
>
>
> inline bool is_char_ptr( wchar_t* )
> {
> return true;
> }
>
> inline bool is_char_ptr( const wchar_t* )
> {
> return true;
> }
>
>
> template< class T >
> inline long is_char_ptr( const T& )
> {
> return 0L;
> }
>
> template< class T >
> inline iterator_range<T*>
> make_range( T* const r, bool )
> {
> return iterator_range<T*>( r, r + length(r) );
> }
>
> template< class T >
> inline iterator_range<typename range_iterator<T>::type>
> make_range( T& r, long )
> {
> return boost::make_iterator_range( r );
> }
>
> }
>
> template< class Range >
> inline iterator_range<typename range_iterator<Range>::type>
> as_literal( Range& r )
> {
> return range_detail::make_range( r, range_detail::is_char_ptr(r) );
> }
>
> template< class Range >
> inline iterator_range<typename range_iterator<const Range>::type>
> as_literal( const Range& r )
> {
> return range_detail::make_range( r, range_detail::is_char_ptr(r) );
> }
>
> template< class Char, std::size_t sz >
> inline iterator_range<Char*> as_literal( Char (&arr)[sz] )
> {
> return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );
> }
>
> template< class Char, std::size_t sz >
> inline iterator_range<const Char*> as_literal( const Char (&arr)[sz] )
> {
> return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );
> }
>}
># 21 "/usr/include/boost/algorithm/string/find_format.hpp" 2 3 4
>
># 1 "/usr/include/boost/algorithm/string/concept.hpp" 1 3 4
># 23 "/usr/include/boost/algorithm/string/concept.hpp" 3 4
>namespace boost {
> namespace algorithm {
># 34 "/usr/include/boost/algorithm/string/concept.hpp" 3 4
> template<typename FinderT, typename IteratorT>
> struct FinderConcept
> {
> private:
> typedef iterator_range<IteratorT> range;
> public:
> void constraints()
> {
>
> r=(*pF)(i,i);
> }
> private:
> range r;
> IteratorT i;
> FinderT* pF;
> };
># 61 "/usr/include/boost/algorithm/string/concept.hpp" 3 4
> template<typename FormatterT, typename FinderT, typename IteratorT>
> struct FormatterConcept
> {
> public:
> void constraints()
> {
>
> ::boost::begin((*pFo)( (*pF)(i,i) ));
> ::boost::end((*pFo)( (*pF)(i,i) ));
> }
> private:
> IteratorT i;
> FinderT* pF;
> FormatterT *pFo;
> };
>
> }
>}
># 23 "/usr/include/boost/algorithm/string/find_format.hpp" 2 3 4
># 1 "/usr/include/boost/algorithm/string/detail/find_format.hpp" 1 3 4
># 18 "/usr/include/boost/algorithm/string/detail/find_format.hpp" 3 4
># 1 "/usr/include/boost/algorithm/string/detail/find_format_store.hpp" 1 3 4
># 17 "/usr/include/boost/algorithm/string/detail/find_format_store.hpp" 3 4
>namespace boost {
> namespace algorithm {
> namespace detail {
>
>
>
>
>
>
>
> template<
> typename ForwardIteratorT,
> typename FormatterT,
> typename FormatResultT >
> class find_format_store :
> public iterator_range<ForwardIteratorT>
> {
> public:
>
> typedef iterator_range<ForwardIteratorT> base_type;
> typedef FormatterT formatter_type;
> typedef FormatResultT format_result_type;
>
> public:
>
> find_format_store(
> const base_type& FindResult,
> const format_result_type& FormatResult,
> const formatter_type& Formatter ) :
> base_type(FindResult),
> m_FormatResult(FormatResult),
> m_Formatter(Formatter) {}
>
>
> template< typename FindResultT >
> find_format_store& operator=( FindResultT FindResult )
> {
> iterator_range<ForwardIteratorT>::operator=(FindResult);
> if( !this->empty() ) {
> m_FormatResult=m_Formatter(FindResult);
> }
>
> return *this;
> }
>
>
> const format_result_type& format_result()
> {
> return m_FormatResult;
> }
>
> private:
> format_result_type m_FormatResult;
> const formatter_type& m_Formatter;
> };
>
> template<typename InputT, typename FindResultT>
> bool check_find_result(InputT&, FindResultT& FindResult)
> {
> typedef typename
> range_const_iterator<InputT>::type input_iterator_type;
> iterator_range<input_iterator_type> ResultRange(FindResult);
> return !ResultRange.empty();
> }
>
>
>
>
> }
> }
>}
># 19 "/usr/include/boost/algorithm/string/detail/find_format.hpp" 2 3 4
># 1 "/usr/include/boost/algorithm/string/detail/replace_storage.hpp" 1 3 4
># 17 "/usr/include/boost/algorithm/string/detail/replace_storage.hpp" 3 4
># 1 "/usr/include/boost/algorithm/string/sequence_traits.hpp" 1 3 4
># 16 "/usr/include/boost/algorithm/string/sequence_traits.hpp" 3 4
># 1 "/usr/include/boost/algorithm/string/yes_no_type.hpp" 1 3 4
># 14 "/usr/include/boost/algorithm/string/yes_no_type.hpp" 3 4
>namespace boost {
> namespace algorithm {
>
>
>
>
>
> template<int I> struct size_descriptor
> {
> typedef char (& type)[I];
> };
>
> typedef size_descriptor<1>::type yes_type;
> typedef size_descriptor<2>::type no_type;
>
> }
>}
># 17 "/usr/include/boost/algorithm/string/sequence_traits.hpp" 2 3 4
># 34 "/usr/include/boost/algorithm/string/sequence_traits.hpp" 3 4
>namespace boost {
> namespace algorithm {
># 85 "/usr/include/boost/algorithm/string/sequence_traits.hpp" 3 4
> template< typename T >
> class has_native_replace
> {
># 96 "/usr/include/boost/algorithm/string/sequence_traits.hpp" 3 4
> public:
>
>
>
> static const bool value=false;
>
>
>
>
> typedef mpl::bool_<has_native_replace<T>::value> type;
> };
>
>
>
>
>
>
>
> template< typename T >
> class has_stable_iterators
> {
>
>
>
>
>
>
>
> public:
>
>
>
> static const bool value=false;
>
>
>
> typedef mpl::bool_<has_stable_iterators<T>::value> type;
> };
>
>
>
>
>
>
>
> template< typename T >
> class has_const_time_insert
> {
>
>
>
>
>
>
>
> public:
>
>
>
> static const bool value=false;
>
>
>
> typedef mpl::bool_<has_const_time_insert<T>::value> type;
> };
>
>
>
>
>
>
>
> template< typename T >
> class has_const_time_erase
> {
>
>
>
>
>
>
>
> public:
>
>
>
> static const bool value=false;
>
>
>
> typedef mpl::bool_<has_const_time_erase<T>::value> type;
> };
>
> }
>}
># 18 "/usr/include/boost/algorithm/string/detail/replace_storage.hpp" 2 3 4
># 1 "/usr/include/boost/algorithm/string/detail/sequence.hpp" 1 3 4
># 22 "/usr/include/boost/algorithm/string/detail/sequence.hpp" 3 4
>namespace boost {
> namespace algorithm {
> namespace detail {
>
>
>
> template< typename InputT, typename ForwardIteratorT >
> inline void insert(
> InputT& Input,
> typename InputT::iterator At,
> ForwardIteratorT Begin,
> ForwardIteratorT End )
> {
> Input.insert( At, Begin, End );
> }
>
> template< typename InputT, typename InsertT >
> inline void insert(
> InputT& Input,
> typename InputT::iterator At,
> const InsertT& Insert )
> {
> ::boost::algorithm::detail::insert( Input, At, ::boost::begin(Insert), ::boost::end(Insert) );
> }
>
>
>
>
>
>
>
> template< typename InputT >
> inline typename InputT::iterator erase(
> InputT& Input,
> typename InputT::iterator From,
> typename InputT::iterator To )
> {
> return Input.erase( From, To );
> }
>
>
>
>
>
> template< bool HasConstTimeOperations >
> struct replace_const_time_helper
> {
> template< typename InputT, typename ForwardIteratorT >
> void operator()(
> InputT& Input,
> typename InputT::iterator From,
> typename InputT::iterator To,
> ForwardIteratorT Begin,
> ForwardIteratorT End )
> {
>
> ForwardIteratorT InsertIt=Begin;
> typename InputT::iterator InputIt=From;
> for(; InsertIt!=End && InputIt!=To; InsertIt++, InputIt++ )
> {
> *InputIt=*InsertIt;
> }
>
> if ( InsertIt!=End )
> {
>
> Input.insert( InputIt, InsertIt, End );
> }
> else
> {
> if ( InputIt!=To )
> {
>
> Input.erase( InputIt, To );
> }
> }
> }
> };
>
> template<>
> struct replace_const_time_helper< true >
> {
>
> template< typename InputT, typename ForwardIteratorT >
> void operator()(
> InputT& Input,
> typename InputT::iterator From,
> typename InputT::iterator To,
> ForwardIteratorT Begin,
> ForwardIteratorT End )
> {
> typename InputT::iterator At=Input.erase( From, To );
> if ( Begin!=End )
> {
> if(!Input.empty())
> {
> Input.insert( At, Begin, End );
> }
> else
> {
> Input.insert( Input.begin(), Begin, End );
> }
> }
> }
> };
>
>
> template< bool HasNative >
> struct replace_native_helper
> {
> template< typename InputT, typename ForwardIteratorT >
> void operator()(
> InputT& Input,
> typename InputT::iterator From,
> typename InputT::iterator To,
> ForwardIteratorT Begin,
> ForwardIteratorT End )
> {
> replace_const_time_helper<
> boost::mpl::and_<
> has_const_time_insert<InputT>,
> has_const_time_erase<InputT> >::value >()(
> Input, From, To, Begin, End );
> }
> };
>
>
> template<>
> struct replace_native_helper< true >
> {
> template< typename InputT, typename ForwardIteratorT >
> void operator()(
> InputT& Input,
> typename InputT::iterator From,
> typename InputT::iterator To,
> ForwardIteratorT Begin,
> ForwardIteratorT End )
> {
> Input.replace( From, To, Begin, End );
> }
> };
>
>
>
> template< typename InputT, typename ForwardIteratorT >
> inline void replace(
> InputT& Input,
> typename InputT::iterator From,
> typename InputT::iterator To,
> ForwardIteratorT Begin,
> ForwardIteratorT End )
> {
> replace_native_helper< has_native_replace<InputT>::value >()(
> Input, From, To, Begin, End );
> }
>
> template< typename InputT, typename InsertT >
> inline void replace(
> InputT& Input,
> typename InputT::iterator From,
> typename InputT::iterator To,
> const InsertT& Insert )
> {
> if(From!=To)
> {
> ::boost::algorithm::detail::replace( Input, From, To, ::boost::begin(Insert), ::boost::end(Insert) );
> }
> else
> {
> ::boost::algorithm::detail::insert( Input, From, ::boost::begin(Insert), ::boost::end(Insert) );
> }
> }
>
> }
> }
>}
># 19 "/usr/include/boost/algorithm/string/detail/replace_storage.hpp" 2 3 4
>
>namespace boost {
> namespace algorithm {
> namespace detail {
>
>
>
> template< typename StorageT, typename OutputIteratorT >
> inline OutputIteratorT move_from_storage(
> StorageT& Storage,
> OutputIteratorT DestBegin,
> OutputIteratorT DestEnd )
> {
> OutputIteratorT OutputIt=DestBegin;
>
> while( !Storage.empty() && OutputIt!=DestEnd )
> {
> *OutputIt=Storage.front();
> Storage.pop_front();
> ++OutputIt;
> }
>
> return OutputIt;
> }
>
> template< typename StorageT, typename WhatT >
> inline void copy_to_storage(
> StorageT& Storage,
> const WhatT& What )
> {
> Storage.insert( Storage.end(), ::boost::begin(What), ::boost::end(What) );
> }
>
>
>
>
> template< bool HasStableIterators >
> struct process_segment_helper
> {
>
> template<
> typename StorageT,
> typename InputT,
> typename ForwardIteratorT >
> ForwardIteratorT operator()(
> StorageT& Storage,
> InputT& ,
> ForwardIteratorT InsertIt,
> ForwardIteratorT SegmentBegin,
> ForwardIteratorT SegmentEnd )
> {
>
> ForwardIteratorT It=::boost::algorithm::detail::move_from_storage( Storage, InsertIt, SegmentBegin );
>
>
>
>
>
>
> if( Storage.empty() )
> {
> if( It==SegmentBegin )
> {
>
> return SegmentEnd;
> }
> else
> {
>
> return std::copy( SegmentBegin, SegmentEnd, It );
> }
> }
> else
> {
>
> while( It!=SegmentEnd )
> {
>
> Storage.push_back( *It );
>
> *It=Storage.front();
> Storage.pop_front();
>
>
> ++It;
> }
>
> return It;
> }
> }
> };
>
> template<>
> struct process_segment_helper< true >
> {
>
> template<
> typename StorageT,
> typename InputT,
> typename ForwardIteratorT >
> ForwardIteratorT operator()(
> StorageT& Storage,
> InputT& Input,
> ForwardIteratorT InsertIt,
> ForwardIteratorT SegmentBegin,
> ForwardIteratorT SegmentEnd )
>
> {
>
> ::boost::algorithm::detail::replace( Input, InsertIt, SegmentBegin, Storage );
>
> Storage.clear();
>
> return SegmentEnd;
> }
> };
>
>
> template<
> typename StorageT,
> typename InputT,
> typename ForwardIteratorT >
> inline ForwardIteratorT process_segment(
> StorageT& Storage,
> InputT& Input,
> ForwardIteratorT InsertIt,
> ForwardIteratorT SegmentBegin,
> ForwardIteratorT SegmentEnd )
> {
> return
> process_segment_helper<
> has_stable_iterators<InputT>::value>()(
> Storage, Input, InsertIt, SegmentBegin, SegmentEnd );
> }
>
>
> }
> }
>}
># 20 "/usr/include/boost/algorithm/string/detail/find_format.hpp" 2 3 4
>
>namespace boost {
> namespace algorithm {
> namespace detail {
>
>
>
> template<
> typename OutputIteratorT,
> typename InputT,
> typename FormatterT,
> typename FindResultT,
> typename FormatResultT >
> inline OutputIteratorT find_format_copy_impl2(
> OutputIteratorT Output,
> const InputT& Input,
> FormatterT Formatter,
> const FindResultT& FindResult,
> const FormatResultT& FormatResult )
> {
> typedef find_format_store<
> typename
> range_const_iterator<InputT>::type,
> FormatterT,
> FormatResultT > store_type;
>
>
> store_type M( FindResult, FormatResult, Formatter );
>
> if ( !M )
> {
>
> Output = std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
> return Output;
> }
>
>
> Output = std::copy( ::boost::begin(Input), ::boost::begin(M), Output );
>
>
> Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
>
> Output = std::copy( M.end(), ::boost::end(Input), Output );
>
> return Output;
> }
>
> template<
> typename OutputIteratorT,
> typename InputT,
> typename FormatterT,
> typename FindResultT >
> inline OutputIteratorT find_format_copy_impl(
> OutputIteratorT Output,
> const InputT& Input,
> FormatterT Formatter,
> const FindResultT& FindResult )
> {
> if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
> return ::boost::algorithm::detail::find_format_copy_impl2(
> Output,
> Input,
> Formatter,
> FindResult,
> Formatter(FindResult) );
> } else {
> return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
> }
> }
>
>
>
>
> template<
> typename InputT,
> typename FormatterT,
> typename FindResultT,
> typename FormatResultT >
> inline InputT find_format_copy_impl2(
> const InputT& Input,
> FormatterT Formatter,
> const FindResultT& FindResult,
> const FormatResultT& FormatResult)
> {
> typedef find_format_store<
> typename
> range_const_iterator<InputT>::type,
> FormatterT,
> FormatResultT > store_type;
>
>
> store_type M( FindResult, FormatResult, Formatter );
>
> if ( !M )
> {
>
> return InputT( Input );
> }
>
> InputT Output;
>
> boost::algorithm::detail::insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() );
>
> boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() );
>
> boost::algorithm::detail::insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) );
>
> return Output;
> }
>
> template<
> typename InputT,
> typename FormatterT,
> typename FindResultT >
> inline InputT find_format_copy_impl(
> const InputT& Input,
> FormatterT Formatter,
> const FindResultT& FindResult)
> {
> if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
> return ::boost::algorithm::detail::find_format_copy_impl2(
> Input,
> Formatter,
> FindResult,
> Formatter(FindResult) );
> } else {
> return Input;
> }
> }
>
>
>
> template<
> typename InputT,
> typename FormatterT,
> typename FindResultT,
> typename FormatResultT >
> inline void find_format_impl2(
> InputT& Input,
> FormatterT Formatter,
> const FindResultT& FindResult,
> const FormatResultT& FormatResult)
> {
> typedef find_format_store<
> typename
> range_iterator<InputT>::type,
> FormatterT,
> FormatResultT > store_type;
>
>
> store_type M( FindResult, FormatResult, Formatter );
>
> if ( !M )
> {
>
> return;
> }
>
>
> ::boost::algorithm::detail::replace( Input, M.begin(), M.end(), M.format_result() );
> }
>
> template<
> typename InputT,
> typename FormatterT,
> typename FindResultT >
> inline void find_format_impl(
> InputT& Input,
> FormatterT Formatter,
> const FindResultT& FindResult)
> {
> if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
> ::boost::algorithm::detail::find_format_impl2(
> Input,
> Formatter,
> FindResult,
> Formatter(FindResult) );
> }
> }
>
> }
> }
>}
># 24 "/usr/include/boost/algorithm/string/find_format.hpp" 2 3 4
># 1 "/usr/include/boost/algorithm/string/detail/find_format_all.hpp" 1 3 4
># 21 "/usr/include/boost/algorithm/string/detail/find_format_all.hpp" 3 4
>namespace boost {
> namespace algorithm {
> namespace detail {
>
>
>
> template<
> typename OutputIteratorT,
> typename InputT,
> typename FinderT,
> typename FormatterT,
> typename FindResultT,
> typename FormatResultT >
> inline OutputIteratorT find_format_all_copy_impl2(
> OutputIteratorT Output,
> const InputT& Input,
> FinderT Finder,
> FormatterT Formatter,
> const FindResultT& FindResult,
> const FormatResultT& FormatResult )
> {
> typedef typename
> range_const_iterator<InputT>::type input_iterator_type;
>
> typedef find_format_store<
> input_iterator_type,
> FormatterT,
> FormatResultT > store_type;
>
>
> store_type M( FindResult, FormatResult, Formatter );
>
>
> input_iterator_type LastMatch=::boost::begin(Input);
>
>
> while( M )
> {
>
> Output = std::copy( LastMatch, M.begin(), Output );
>
> Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
>
>
> LastMatch=M.end();
> M=Finder( LastMatch, ::boost::end(Input) );
> }
>
>
> Output = std::copy( LastMatch, ::boost::end(Input), Output );
>
> return Output;
> }
>
> template<
> typename OutputIteratorT,
> typename InputT,
> typename FinderT,
> typename FormatterT,
> typename FindResultT >
> inline OutputIteratorT find_format_all_copy_impl(
> OutputIteratorT Output,
> const InputT& Input,
> FinderT Finder,
> FormatterT Formatter,
> const FindResultT& FindResult )
> {
> if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
> return ::boost::algorithm::detail::find_format_all_copy_impl2(
> Output,
> Input,
> Finder,
> Formatter,
> FindResult,
> Formatter(FindResult) );
> } else {
> return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
> }
> }
>
>
>
> template<
> typename InputT,
> typename FinderT,
> typename FormatterT,
> typename FindResultT,
> typename FormatResultT >
> inline InputT find_format_all_copy_impl2(
> const InputT& Input,
> FinderT Finder,
> FormatterT Formatter,
> const FindResultT& FindResult,
> const FormatResultT& FormatResult)
> {
> typedef typename
> range_const_iterator<InputT>::type input_iterator_type;
>
> typedef find_format_store<
> input_iterator_type,
> FormatterT,
> FormatResultT > store_type;
>
>
> store_type M( FindResult, FormatResult, Formatter );
>
>
> input_iterator_type LastMatch=::boost::begin(Input);
>
>
> InputT Output;
>
>
> while( M )
> {
>
> boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, M.begin() );
>
> boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() );
>
>
> LastMatch=M.end();
> M=Finder( LastMatch, ::boost::end(Input) );
> }
>
>
> ::boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) );
>
> return Output;
> }
>
> template<
> typename InputT,
> typename FinderT,
> typename FormatterT,
> typename FindResultT >
> inline InputT find_format_all_copy_impl(
> const InputT& Input,
> FinderT Finder,
> FormatterT Formatter,
> const FindResultT& FindResult)
> {
> if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
> return ::boost::algorithm::detail::find_format_all_copy_impl2(
> Input,
> Finder,
> Formatter,
> FindResult,
> Formatter(FindResult) );
> } else {
> return Input;
> }
> }
>
>
>
> template<
> typename InputT,
> typename FinderT,
> typename FormatterT,
> typename FindResultT,
> typename FormatResultT >
> inline void find_format_all_impl2(
> InputT& Input,
> FinderT Finder,
> FormatterT Formatter,
> FindResultT FindResult,
> FormatResultT FormatResult)
> {
> typedef typename
> range_iterator<InputT>::type input_iterator_type;
> typedef find_format_store<
> input_iterator_type,
> FormatterT,
> FormatResultT > store_type;
>
>
> store_type M( FindResult, FormatResult, Formatter );
>
>
> std::deque<
> typename range_value<InputT>::type> Storage;
>
>
> input_iterator_type InsertIt=::boost::begin(Input);
> input_iterator_type SearchIt=::boost::begin(Input);
>
> while( M )
> {
>
> InsertIt=process_segment(
> Storage,
> Input,
> InsertIt,
> SearchIt,
> M.begin() );
>
>
> SearchIt=M.end();
>
>
> ::boost::algorithm::detail::copy_to_storage( Storage, M.format_result() );
>
>
> M=Finder( SearchIt, ::boost::end(Input) );
> }
>
>
> InsertIt=::boost::algorithm::detail::process_segment(
> Storage,
> Input,
> InsertIt,
> SearchIt,
> ::boost::end(Input) );
>
> if ( Storage.empty() )
> {
>
> ::boost::algorithm::detail::erase( Input, InsertIt, ::boost::end(Input) );
> }
> else
> {
>
> ::boost::algorithm::detail::insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() );
> }
> }
>
> template<
> typename InputT,
> typename FinderT,
> typename FormatterT,
> typename FindResultT >
> inline void find_format_all_impl(
> InputT& Input,
> FinderT Finder,
> FormatterT Formatter,
> FindResultT FindResult)
> {
> if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
> ::boost::algorithm::detail::find_format_all_impl2(
> Input,
> Finder,
> Formatter,
> FindResult,
> Formatter(FindResult) );
> }
> }
>
> }
> }
>}
># 25 "/usr/include/boost/algorithm/string/find_format.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost {
> namespace algorithm {
># 53 "/usr/include/boost/algorithm/string/find_format.hpp" 3 4
> template<
> typename OutputIteratorT,
> typename RangeT,
> typename FinderT,
> typename FormatterT>
> inline OutputIteratorT find_format_copy(
> OutputIteratorT Output,
> const RangeT& Input,
> FinderT Finder,
> FormatterT Formatter )
> {
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<RangeT>::type> )>::failed> boost_concept_check69 __attribute__((unused))
>
>
>
> ;
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<RangeT>::type> )>::failed> boost_concept_check74 __attribute__((unused))
>
>
>
> ;
>
> iterator_range<typename range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
>
> return detail::find_format_copy_impl(
> Output,
> lit_input,
> Formatter,
> Finder( ::boost::begin(lit_input), ::boost::end(lit_input) ) );
> }
>
>
>
>
>
> template<
> typename SequenceT,
> typename FinderT,
> typename FormatterT>
> inline SequenceT find_format_copy(
> const SequenceT& Input,
> FinderT Finder,
> FormatterT Formatter )
> {
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check103 __attribute__((unused))
>
>
>
> ;
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check108 __attribute__((unused))
>
>
>
> ;
>
> return detail::find_format_copy_impl(
> Input,
> Formatter,
> Finder(::boost::begin(Input), ::boost::end(Input)));
> }
># 125 "/usr/include/boost/algorithm/string/find_format.hpp" 3 4
> template<
> typename SequenceT,
> typename FinderT,
> typename FormatterT>
> inline void find_format(
> SequenceT& Input,
> FinderT Finder,
> FormatterT Formatter)
> {
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check139 __attribute__((unused))
>
>
>
> ;
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check144 __attribute__((unused))
>
>
>
> ;
>
> detail::find_format_impl(
> Input,
> Formatter,
> Finder(::boost::begin(Input), ::boost::end(Input)));
> }
># 172 "/usr/include/boost/algorithm/string/find_format.hpp" 3 4
> template<
> typename OutputIteratorT,
> typename RangeT,
> typename FinderT,
> typename FormatterT>
> inline OutputIteratorT find_format_all_copy(
> OutputIteratorT Output,
> const RangeT& Input,
> FinderT Finder,
> FormatterT Formatter)
> {
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<RangeT>::type> )>::failed> boost_concept_check188 __attribute__((unused))
>
>
>
> ;
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<RangeT>::type> )>::failed> boost_concept_check193 __attribute__((unused))
>
>
>
> ;
>
> iterator_range<typename range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
>
> return detail::find_format_all_copy_impl(
> Output,
> lit_input,
> Finder,
> Formatter,
> Finder(::boost::begin(lit_input), ::boost::end(lit_input)));
> }
>
>
>
>
>
> template<
> typename SequenceT,
> typename FinderT,
> typename FormatterT >
> inline SequenceT find_format_all_copy(
> const SequenceT& Input,
> FinderT Finder,
> FormatterT Formatter )
> {
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check223 __attribute__((unused))
>
>
>
> ;
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check228 __attribute__((unused))
>
>
>
> ;
>
> return detail::find_format_all_copy_impl(
> Input,
> Finder,
> Formatter,
> Finder( ::boost::begin(Input), ::boost::end(Input) ) );
> }
># 247 "/usr/include/boost/algorithm/string/find_format.hpp" 3 4
> template<
> typename SequenceT,
> typename FinderT,
> typename FormatterT >
> inline void find_format_all(
> SequenceT& Input,
> FinderT Finder,
> FormatterT Formatter )
> {
>
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check261 __attribute__((unused))
>
>
>
> ;
> typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check266 __attribute__((unused))
>
>
>
> ;
>
> detail::find_format_all_impl(
> Input,
> Finder,
> Formatter,
> Finder(::boost::begin(Input), ::boost::end(Input)));
>
> }
>
> }
>
>
> using algorithm::find_format_copy;
> using algorithm::find_format;
> using algorithm::find_format_all_copy;
> using algorithm::find_format_all;
>
>}
># 23 "/usr/include/boost/algorithm/string/replace.hpp" 2 3 4
># 1 "/usr/include/boost/algorithm/string/finder.hpp" 1 3 4
># 22 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
># 1 "/usr/include/boost/algorithm/string/constants.hpp" 1 3 4
># 14 "/usr/include/boost/algorithm/string/constants.hpp" 3 4
>namespace boost {
> namespace algorithm {
>
>
>
>
>
> enum token_compress_mode_type
> {
> token_compress_on,
> token_compress_off
> };
>
> }
>
>
> using algorithm::token_compress_on;
> using algorithm::token_compress_off;
>
>}
># 23 "/usr/include/boost/algorithm/string/finder.hpp" 2 3 4
># 1 "/usr/include/boost/algorithm/string/detail/finder.hpp" 1 3 4
># 24 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
>namespace boost {
> namespace algorithm {
> namespace detail {
># 36 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
> template<typename SearchIteratorT,typename PredicateT>
> struct first_finderF
> {
> typedef SearchIteratorT search_iterator_type;
>
>
> template< typename SearchT >
> first_finderF( const SearchT& Search, PredicateT Comp ) :
> m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
> first_finderF(
> search_iterator_type SearchBegin,
> search_iterator_type SearchEnd,
> PredicateT Comp ) :
> m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {}
>
>
> template< typename ForwardIteratorT >
> iterator_range<ForwardIteratorT>
> operator()(
> ForwardIteratorT Begin,
> ForwardIteratorT End ) const
> {
> typedef iterator_range<ForwardIteratorT> result_type;
> typedef ForwardIteratorT input_iterator_type;
>
>
> for(input_iterator_type OuterIt=Begin;
> OuterIt!=End;
> ++OuterIt)
> {
>
> if( boost::empty(m_Search) )
> return result_type( End, End );
>
> input_iterator_type InnerIt=OuterIt;
> search_iterator_type SubstrIt=m_Search.begin();
> for(;
> InnerIt!=End && SubstrIt!=m_Search.end();
> ++InnerIt,++SubstrIt)
> {
> if( !( m_Comp(*InnerIt,*SubstrIt) ) )
> break;
> }
>
>
> if ( SubstrIt==m_Search.end() )
> return result_type( OuterIt, InnerIt );
> }
>
> return result_type( End, End );
> }
>
> private:
> iterator_range<search_iterator_type> m_Search;
> PredicateT m_Comp;
> };
># 100 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
> template<typename SearchIteratorT, typename PredicateT>
> struct last_finderF
> {
> typedef SearchIteratorT search_iterator_type;
> typedef first_finderF<
> search_iterator_type,
> PredicateT> first_finder_type;
>
>
> template< typename SearchT >
> last_finderF( const SearchT& Search, PredicateT Comp ) :
> m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
> last_finderF(
> search_iterator_type SearchBegin,
> search_iterator_type SearchEnd,
> PredicateT Comp ) :
> m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {}
>
>
> template< typename ForwardIteratorT >
> iterator_range<ForwardIteratorT>
> operator()(
> ForwardIteratorT Begin,
> ForwardIteratorT End ) const
> {
> typedef iterator_range<ForwardIteratorT> result_type;
>
> if( boost::empty(m_Search) )
> return result_type( End, End );
>
> typedef typename boost::detail::
> iterator_traits<ForwardIteratorT>::iterator_category category;
>
> return findit( Begin, End, category() );
> }
>
> private:
>
> template< typename ForwardIteratorT >
> iterator_range<ForwardIteratorT>
> findit(
> ForwardIteratorT Begin,
> ForwardIteratorT End,
> std::forward_iterator_tag ) const
> {
> typedef iterator_range<ForwardIteratorT> result_type;
>
> first_finder_type first_finder(
> m_Search.begin(), m_Search.end(), m_Comp );
>
> result_type M=first_finder( Begin, End );
> result_type Last=M;
>
> while( M )
> {
> Last=M;
> M=first_finder( ::boost::end(M), End );
> }
>
> return Last;
> }
>
>
> template< typename ForwardIteratorT >
> iterator_range<ForwardIteratorT>
> findit(
> ForwardIteratorT Begin,
> ForwardIteratorT End,
> std::bidirectional_iterator_tag ) const
> {
> typedef iterator_range<ForwardIteratorT> result_type;
> typedef ForwardIteratorT input_iterator_type;
>
>
> for(input_iterator_type OuterIt=End;
> OuterIt!=Begin; )
> {
> input_iterator_type OuterIt2=--OuterIt;
>
> input_iterator_type InnerIt=OuterIt2;
> search_iterator_type SubstrIt=m_Search.begin();
> for(;
> InnerIt!=End && SubstrIt!=m_Search.end();
> ++InnerIt,++SubstrIt)
> {
> if( !( m_Comp(*InnerIt,*SubstrIt) ) )
> break;
> }
>
>
> if( SubstrIt==m_Search.end() )
> return result_type( OuterIt2, InnerIt );
> }
>
> return result_type( End, End );
> }
>
> private:
> iterator_range<search_iterator_type> m_Search;
> PredicateT m_Comp;
> };
># 209 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
> template<typename SearchIteratorT, typename PredicateT>
> struct nth_finderF
> {
> typedef SearchIteratorT search_iterator_type;
> typedef first_finderF<
> search_iterator_type,
> PredicateT> first_finder_type;
> typedef last_finderF<
> search_iterator_type,
> PredicateT> last_finder_type;
>
>
> template< typename SearchT >
> nth_finderF(
> const SearchT& Search,
> int Nth,
> PredicateT Comp) :
> m_Search(::boost::begin(Search), ::boost::end(Search)),
> m_Nth(Nth),
> m_Comp(Comp) {}
> nth_finderF(
> search_iterator_type SearchBegin,
> search_iterator_type SearchEnd,
> int Nth,
> PredicateT Comp) :
> m_Search(SearchBegin, SearchEnd),
> m_Nth(Nth),
> m_Comp(Comp) {}
>
>
> template< typename ForwardIteratorT >
> iterator_range<ForwardIteratorT>
> operator()(
> ForwardIteratorT Begin,
> ForwardIteratorT End ) const
> {
> if(m_Nth>=0)
> {
> return find_forward(Begin, End, m_Nth);
> }
> else
> {
> return find_backward(Begin, End, -m_Nth);
> }
>
> }
>
> private:
>
> template< typename ForwardIteratorT >
> iterator_range<ForwardIteratorT>
> find_forward(
> ForwardIteratorT Begin,
> ForwardIteratorT End,
> unsigned int N) const
> {
> typedef iterator_range<ForwardIteratorT> result_type;
>
>
> if( boost::empty(m_Search) )
> return result_type( End, End );
>
>
> first_finder_type first_finder(
> m_Search.begin(), m_Search.end(), m_Comp );
>
> result_type M( Begin, Begin );
>
> for( unsigned int n=0; n<=N; ++n )
> {
>
> M=first_finder( ::boost::end(M), End );
>
> if ( !M )
> {
>
> return M;
> }
> }
>
> return M;
> }
>
> template< typename ForwardIteratorT >
> iterator_range<ForwardIteratorT>
> find_backward(
> ForwardIteratorT Begin,
> ForwardIteratorT End,
> unsigned int N) const
> {
> typedef iterator_range<ForwardIteratorT> result_type;
>
>
> if( boost::empty(m_Search) )
> return result_type( End, End );
>
>
> last_finder_type last_finder(
> m_Search.begin(), m_Search.end(), m_Comp );
>
> result_type M( End, End );
>
> for( unsigned int n=1; n<=N; ++n )
> {
>
> M=last_finder( Begin, ::boost::begin(M) );
>
> if ( !M )
> {
>
> return M;
> }
> }
>
> return M;
> }
>
>
> private:
> iterator_range<search_iterator_type> m_Search;
> int m_Nth;
> PredicateT m_Comp;
> };
>
>
>
> template<typename ForwardIteratorT>
> iterator_range<ForwardIteratorT>
> find_head_impl(
> ForwardIteratorT Begin,
> ForwardIteratorT End,
> unsigned int N,
> std::forward_iterator_tag )
> {
> typedef ForwardIteratorT input_iterator_type;
> typedef iterator_range<ForwardIteratorT> result_type;
>
> input_iterator_type It=Begin;
> for(
> unsigned int Index=0;
> Index<N && It!=End; ++Index,++It ) {};
>
> return result_type( Begin, It );
> }
>
> template< typename ForwardIteratorT >
> iterator_range<ForwardIteratorT>
> find_head_impl(
> ForwardIteratorT Begin,
> ForwardIteratorT End,
> unsigned int N,
> std::random_access_iterator_tag )
> {
> typedef iterator_range<ForwardIteratorT> result_type;
>
> if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
> return result_type( Begin, End );
>
> return result_type(Begin,Begin+N);
> }
>
>
> template<typename ForwardIteratorT>
> iterator_range<ForwardIteratorT>
> find_head_impl(
> ForwardIteratorT Begin,
> ForwardIteratorT End,
> unsigned int N )
> {
> typedef typename boost::detail::
> iterator_traits<ForwardIteratorT>::iterator_category category;
>
> return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() );
> }
>
> template< typename ForwardIteratorT >
> iterator_range<ForwardIteratorT>
> find_tail_impl(
> ForwardIteratorT Begin,
> ForwardIteratorT End,
> unsigned int N,
> std::forward_iterator_tag )
> {
> typedef ForwardIteratorT input_iterator_type;
> typedef iterator_range<ForwardIteratorT> result_type;
>
> unsigned int Index=0;
> input_iterator_type It=Begin;
> input_iterator_type It2=Begin;
>
>
> for( Index=0; Index<N && It2!=End; ++Index,++It2 ) {};
>
>
> for(; It2!=End; ++It,++It2 ) {};
>
> return result_type( It, It2 );
> }
>
> template< typename ForwardIteratorT >
> iterator_range<ForwardIteratorT>
> find_tail_impl(
> ForwardIteratorT Begin,
> ForwardIteratorT End,
> unsigned int N,
> std::bidirectional_iterator_tag )
> {
> typedef ForwardIteratorT input_iterator_type;
> typedef iterator_range<ForwardIteratorT> result_type;
>
> input_iterator_type It=End;
> for(
> unsigned int Index=0;
> Index<N && It!=Begin; ++Index,--It ) {};
>
> return result_type( It, End );
> }
>
> template< typename ForwardIteratorT >
> iterator_range<ForwardIteratorT>
> find_tail_impl(
> ForwardIteratorT Begin,
> ForwardIteratorT End,
> unsigned int N,
> std::random_access_iterator_tag )
> {
> typedef iterator_range<ForwardIteratorT> result_type;
>
> if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
> return result_type( Begin, End );
>
> return result_type( End-N, End );
> }
>
>
> template< typename ForwardIteratorT >
> iterator_range<ForwardIteratorT>
> find_tail_impl(
> ForwardIteratorT Begin,
> ForwardIteratorT End,
> unsigned int N )
> {
> typedef typename boost::detail::
> iterator_traits<ForwardIteratorT>::iterator_category category;
>
> return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() );
> }
># 468 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
> struct head_finderF
> {
>
> head_finderF( int N ) : m_N(N) {}
>
>
> template< typename ForwardIteratorT >
> iterator_range<ForwardIteratorT>
> operator()(
> ForwardIteratorT Begin,
> ForwardIteratorT End ) const
> {
> if(m_N>=0)
> {
> return ::boost::algorithm::detail::find_head_impl( Begin, End, m_N );
> }
> else
> {
> iterator_range<ForwardIteratorT> Res=
> ::boost::algorithm::detail::find_tail_impl( Begin, End, -m_N );
>
> return ::boost::make_iterator_range(Begin, Res.begin());
> }
> }
>
> private:
> int m_N;
> };
># 506 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
> struct tail_finderF
> {
>
> tail_finderF( int N ) : m_N(N) {}
>
>
> template< typename ForwardIteratorT >
> iterator_range<ForwardIteratorT>
> operator()(
> ForwardIteratorT Begin,
> ForwardIteratorT End ) const
> {
> if(m_N>=0)
> {
> return ::boost::algorithm::detail::find_tail_impl( Begin, End, m_N );
> }
> else
> {
> iterator_range<ForwardIteratorT> Res=
> ::boost::algorithm::detail::find_head_impl( Begin, End, -m_N );
>
> return ::boost::make_iterator_range(Res.end(), End);
> }
> }
>
> private:
> int m_N;
> };
># 547 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
> template< typename PredicateT >
> struct token_finderF
> {
>
> token_finderF(
> PredicateT Pred,
> token_compress_mode_type eCompress=token_compress_off ) :
> m_Pred(Pred), m_eCompress(eCompress) {}
>
>
> template< typename ForwardIteratorT >
> iterator_range<ForwardIteratorT>
> operator()(
> ForwardIteratorT Begin,
> ForwardIteratorT End ) const
> {
> typedef iterator_range<ForwardIteratorT> result_type;
>
> ForwardIteratorT It=std::find_if( Begin, End, m_Pred );
>
> if( It==End )
> {
> return result_type( End, End );
> }
> else
> {
> ForwardIteratorT It2=It;
>
> if( m_eCompress==token_compress_on )
> {
>
> while( It2!=End && m_Pred(*It2) ) ++It2;
> }
> else
> {
>
> ++It2;
> }
>
> return result_type( It, It2 );
> }
> }
>
> private:
> PredicateT m_Pred;
> token_compress_mode_type m_eCompress;
> };
># 602 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
> template<typename ForwardIterator1T>
> struct range_finderF
> {
> typedef ForwardIterator1T input_iterator_type;
> typedef iterator_range<input_iterator_type> result_type;
>
>
> range_finderF(
> input_iterator_type Begin,
> input_iterator_type End ) : m_Range(Begin, End) {}
>
> range_finderF(const iterator_range<input_iterator_type>& Range) :
> m_Range(Range) {}
>
>
> template< typename ForwardIterator2T >
> iterator_range<ForwardIterator2T>
> operator()(
> ForwardIterator2T,
> ForwardIterator2T ) const
> {
>
>
>
>
>
> return m_Range;
>
> }
>
> private:
> iterator_range<input_iterator_type> m_Range;
> };
>
>
> }
> }
>}
># 24 "/usr/include/boost/algorithm/string/finder.hpp" 2 3 4
># 1 "/usr/include/boost/algorithm/string/compare.hpp" 1 3 4
># 24 "/usr/include/boost/algorithm/string/compare.hpp" 3 4
>namespace boost {
> namespace algorithm {
># 34 "/usr/include/boost/algorithm/string/compare.hpp" 3 4
> struct is_equal
> {
>
>
>
>
> template< typename T1, typename T2 >
> bool operator()( const T1& Arg1, const T2& Arg2 ) const
> {
> return Arg1==Arg2;
> }
> };
>
>
>
>
>
>
> struct is_iequal
> {
>
>
>
>
> is_iequal( const std::locale& Loc=std::locale() ) :
> m_Loc( Loc ) {}
>
>
>
>
>
> template< typename T1, typename T2 >
> bool operator()( const T1& Arg1, const T2& Arg2 ) const
> {
>
>
>
> return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);
>
> }
>
> private:
> std::locale m_Loc;
> };
># 86 "/usr/include/boost/algorithm/string/compare.hpp" 3 4
> struct is_less
> {
>
>
>
>
> template< typename T1, typename T2 >
> bool operator()( const T1& Arg1, const T2& Arg2 ) const
> {
> return Arg1<Arg2;
> }
> };
>
>
>
>
>
>
>
> struct is_iless
> {
>
>
>
>
> is_iless( const std::locale& Loc=std::locale() ) :
> m_Loc( Loc ) {}
>
>
>
>
>
> template< typename T1, typename T2 >
> bool operator()( const T1& Arg1, const T2& Arg2 ) const
> {
>
>
>
> return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);
>
> }
>
> private:
> std::locale m_Loc;
> };
># 139 "/usr/include/boost/algorithm/string/compare.hpp" 3 4
> struct is_not_greater
> {
>
>
>
>
> template< typename T1, typename T2 >
> bool operator()( const T1& Arg1, const T2& Arg2 ) const
> {
> return Arg1<=Arg2;
> }
> };
>
>
>
>
>
>
>
> struct is_not_igreater
> {
>
>
>
>
> is_not_igreater( const std::locale& Loc=std::locale() ) :
> m_Loc( Loc ) {}
>
>
>
>
>
> template< typename T1, typename T2 >
> bool operator()( const T1& Arg1, const T2& Arg2 ) const
> {
>
>
>
> return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);
>
> }
>
> private:
> std::locale m_Loc;
> };
>
>
> }
>
>
> using algorithm::is_equal;
> using algorithm::is_iequal;
> using algorithm::is_less;
> using algorithm::is_iless;
> using algorithm::is_not_greater;
> using algorithm::is_not_igreater;
>
>}
># 25 "/usr/include/boost/algorithm/string/finder.hpp" 2 3 4
># 34 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
>namespace boost {
> namespace algorithm {
># 49 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
> template<typename RangeT>
> inline detail::first_finderF<
> typename range_const_iterator<RangeT>::type,
> is_equal>
> first_finder( const RangeT& Search )
> {
> return
> detail::first_finderF<
> typename
> range_const_iterator<RangeT>::type,
> is_equal>( ::boost::as_literal(Search), is_equal() ) ;
> }
>
>
>
>
>
> template<typename RangeT,typename PredicateT>
> inline detail::first_finderF<
> typename range_const_iterator<RangeT>::type,
> PredicateT>
> first_finder(
> const RangeT& Search, PredicateT Comp )
> {
> return
> detail::first_finderF<
> typename
> range_const_iterator<RangeT>::type,
> PredicateT>( ::boost::as_literal(Search), Comp );
> }
># 90 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
> template<typename RangeT>
> inline detail::last_finderF<
> typename range_const_iterator<RangeT>::type,
> is_equal>
> last_finder( const RangeT& Search )
> {
> return
> detail::last_finderF<
> typename
> range_const_iterator<RangeT>::type,
> is_equal>( ::boost::as_literal(Search), is_equal() );
> }
>
>
>
>
> template<typename RangeT, typename PredicateT>
> inline detail::last_finderF<
> typename range_const_iterator<RangeT>::type,
> PredicateT>
> last_finder( const RangeT& Search, PredicateT Comp )
> {
> return
> detail::last_finderF<
> typename
> range_const_iterator<RangeT>::type,
> PredicateT>( ::boost::as_literal(Search), Comp ) ;
> }
># 130 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
> template<typename RangeT>
> inline detail::nth_finderF<
> typename range_const_iterator<RangeT>::type,
> is_equal>
> nth_finder(
> const RangeT& Search,
> int Nth)
> {
> return
> detail::nth_finderF<
> typename
> range_const_iterator<RangeT>::type,
> is_equal>( ::boost::as_literal(Search), Nth, is_equal() ) ;
> }
>
>
>
>
> template<typename RangeT, typename PredicateT>
> inline detail::nth_finderF<
> typename range_const_iterator<RangeT>::type,
> PredicateT>
> nth_finder(
> const RangeT& Search,
> int Nth,
> PredicateT Comp )
> {
> return
> detail::nth_finderF<
> typename
> range_const_iterator<RangeT>::type,
> PredicateT>( ::boost::as_literal(Search), Nth, Comp );
> }
># 175 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
> inline detail::head_finderF
> head_finder( int N )
> {
> return detail::head_finderF(N);
> }
># 192 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
> inline detail::tail_finderF
> tail_finder( int N )
> {
> return detail::tail_finderF(N);
> }
># 216 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
> template< typename PredicateT >
> inline detail::token_finderF<PredicateT>
> token_finder(
> PredicateT Pred,
> token_compress_mode_type eCompress=token_compress_off )
> {
> return detail::token_finderF<PredicateT>( Pred, eCompress );
> }
># 236 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
> template< typename ForwardIteratorT >
> inline detail::range_finderF<ForwardIteratorT>
> range_finder(
> ForwardIteratorT Begin,
> ForwardIteratorT End )
> {
> return detail::range_finderF<ForwardIteratorT>( Begin, End );
> }
>
>
>
>
>
> template< typename ForwardIteratorT >
> inline detail::range_finderF<ForwardIteratorT>
> range_finder( iterator_range<ForwardIteratorT> Range )
> {
> return detail::range_finderF<ForwardIteratorT>( Range );
> }
>
> }
>
>
> using algorithm::first_finder;
> using algorithm::last_finder;
> using algorithm::nth_finder;
> using algorithm::head_finder;
> using algorithm::tail_finder;
> using algorithm::token_finder;
> using algorithm::range_finder;
>
>}
># 24 "/usr/include/boost/algorithm/string/replace.hpp" 2 3 4
># 1 "/usr/include/boost/algorithm/string/formatter.hpp" 1 3 4
># 19 "/usr/include/boost/algorithm/string/formatter.hpp" 3 4
># 1 "/usr/include/boost/algorithm/string/detail/formatter.hpp" 1 3 4
># 20 "/usr/include/boost/algorithm/string/detail/formatter.hpp" 3 4
># 1 "/usr/include/boost/algorithm/string/detail/util.hpp" 1 3 4
># 18 "/usr/include/boost/algorithm/string/detail/util.hpp" 3 4
>namespace boost {
> namespace algorithm {
> namespace detail {
># 31 "/usr/include/boost/algorithm/string/detail/util.hpp" 3 4
> template< typename CharT >
> struct empty_container
> {
> typedef empty_container<CharT> type;
> typedef CharT value_type;
> typedef std::size_t size_type;
> typedef std::ptrdiff_t difference_type;
> typedef const value_type& reference;
> typedef const value_type& const_reference;
> typedef const value_type* iterator;
> typedef const value_type* const_iterator;
>
>
>
> const_iterator begin() const
> {
> return reinterpret_cast<const_iterator>(0);
> }
>
> const_iterator end() const
> {
> return reinterpret_cast<const_iterator>(0);
> }
>
> bool empty() const
> {
> return false;
> }
>
> size_type size() const
> {
> return 0;
> }
> };
>
>
>
>
> template<typename InputIteratorT, typename OutputIteratorT>
> inline OutputIteratorT bounded_copy(
> InputIteratorT First,
> InputIteratorT Last,
> OutputIteratorT DestFirst,
> OutputIteratorT DestLast )
> {
> InputIteratorT InputIt=First;
> OutputIteratorT OutputIt=DestFirst;
> for(; InputIt!=Last && OutputIt!=DestLast; InputIt++, OutputIt++ )
> {
> *OutputIt=*InputIt;
> }
>
> return OutputIt;
> }
>
>
>
>
> template<
> typename SeqT,
> typename IteratorT=typename SeqT::const_iterator >
> struct copy_iterator_rangeF :
> public std::unary_function< iterator_range<IteratorT>, SeqT >
> {
> SeqT operator()( const iterator_range<IteratorT>& Range ) const
> {
> return copy_range<SeqT>(Range);
> }
> };
>
> }
> }
>}
># 21 "/usr/include/boost/algorithm/string/detail/formatter.hpp" 2 3 4
>
>
>
>namespace boost {
> namespace algorithm {
> namespace detail {
>
>
>
>
> template<typename RangeT>
> struct const_formatF
> {
> private:
> typedef typename
> range_const_iterator<RangeT>::type format_iterator;
> typedef iterator_range<format_iterator> result_type;
>
> public:
>
> const_formatF(const RangeT& Format) :
> m_Format(::boost::begin(Format), ::boost::end(Format)) {}
># 53 "/usr/include/boost/algorithm/string/detail/formatter.hpp" 3 4
> template<typename Range2T>
> const result_type& operator()(const Range2T&) const
> {
> return m_Format;
> }
>
> private:
> result_type m_Format;
> };
>
>
>
>
> template<typename RangeT>
> struct identity_formatF
> {
>
> template< typename Range2T >
> const RangeT& operator()(const Range2T& Replace) const
> {
> return RangeT(::boost::begin(Replace), ::boost::end(Replace));
> }
> };
>
>
>
>
> template< typename CharT >
> struct empty_formatF
> {
> template< typename ReplaceT >
> empty_container<CharT> operator()(const ReplaceT&) const
> {
> return empty_container<CharT>();
> }
> };
>
>
>
>
> template<typename FinderT>
> struct dissect_formatF
> {
> public:
>
> dissect_formatF(FinderT Finder) :
> m_Finder(Finder) {}
>
>
> template<typename RangeT>
> inline iterator_range<
> typename range_const_iterator<RangeT>::type>
> operator()(const RangeT& Replace) const
> {
> return m_Finder(::boost::begin(Replace), ::boost::end(Replace));
> }
>
> private:
> FinderT m_Finder;
> };
>
>
> }
> }
>}
># 20 "/usr/include/boost/algorithm/string/formatter.hpp" 2 3 4
># 32 "/usr/include/boost/algorithm/string/formatter.hpp" 3 4
>namespace boost {
> namespace algorithm {
># 45 "/usr/include/boost/algorithm/string/formatter.hpp" 3 4
> template<typename RangeT>
> inline detail::const_formatF<
> iterator_range<
> typename range_const_iterator<RangeT>::type> >
> const_formatter(const RangeT& Format)
> {
> return detail::const_formatF<
> iterator_range<
> typename range_const_iterator<RangeT>::type> >(::boost::as_literal(Format));
> }
># 63 "/usr/include/boost/algorithm/string/formatter.hpp" 3 4
> template<typename RangeT>
> inline detail::identity_formatF<
> iterator_range<
> typename range_const_iterator<RangeT>::type> >
> identity_formatter()
> {
> return detail::identity_formatF<
> iterator_range<
> typename range_const_iterator<RangeT>::type> >();
> }
># 83 "/usr/include/boost/algorithm/string/formatter.hpp" 3 4
> template<typename RangeT>
> inline detail::empty_formatF<
> typename range_value<RangeT>::type>
> empty_formatter(const RangeT&)
> {
> return detail::empty_formatF<
> typename range_value<RangeT>::type>();
> }
># 101 "/usr/include/boost/algorithm/string/formatter.hpp" 3 4
> template<typename FinderT>
> inline detail::dissect_formatF< FinderT >
> dissect_formatter(const FinderT& Finder)
> {
> return detail::dissect_formatF<FinderT>(Finder);
> }
>
>
> }
>
>
> using algorithm::const_formatter;
> using algorithm::identity_formatter;
> using algorithm::empty_formatter;
> using algorithm::dissect_formatter;
>
>}
># 25 "/usr/include/boost/algorithm/string/replace.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost {
> namespace algorithm {
># 52 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<
> typename OutputIteratorT,
> typename Range1T,
> typename Range2T>
> inline OutputIteratorT replace_range_copy(
> OutputIteratorT Output,
> const Range1T& Input,
> const iterator_range<
> typename
> range_const_iterator<Range1T>::type>& SearchRange,
> const Range2T& Format)
> {
> return ::boost::algorithm::find_format_copy(
> Output,
> Input,
> ::boost::algorithm::range_finder(SearchRange),
> ::boost::algorithm::const_formatter(Format));
> }
>
>
>
>
>
> template<typename SequenceT, typename RangeT>
> inline SequenceT replace_range_copy(
> const SequenceT& Input,
> const iterator_range<
> typename
> range_const_iterator<SequenceT>::type>& SearchRange,
> const RangeT& Format)
> {
> return ::boost::algorithm::find_format_copy(
> Input,
> ::boost::algorithm::range_finder(SearchRange),
> ::boost::algorithm::const_formatter(Format));
> }
># 98 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<typename SequenceT, typename RangeT>
> inline void replace_range(
> SequenceT& Input,
> const iterator_range<
> typename
> range_iterator<SequenceT>::type>& SearchRange,
> const RangeT& Format)
> {
> ::boost::algorithm::find_format(
> Input,
> ::boost::algorithm::range_finder(SearchRange),
> ::boost::algorithm::const_formatter(Format));
> }
># 130 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<
> typename OutputIteratorT,
> typename Range1T,
> typename Range2T,
> typename Range3T>
> inline OutputIteratorT replace_first_copy(
> OutputIteratorT Output,
> const Range1T& Input,
> const Range2T& Search,
> const Range3T& Format)
> {
> return ::boost::algorithm::find_format_copy(
> Output,
> Input,
> ::boost::algorithm::first_finder(Search),
> ::boost::algorithm::const_formatter(Format) );
> }
>
>
>
>
>
> template<typename SequenceT, typename Range1T, typename Range2T>
> inline SequenceT replace_first_copy(
> const SequenceT& Input,
> const Range1T& Search,
> const Range2T& Format )
> {
> return ::boost::algorithm::find_format_copy(
> Input,
> ::boost::algorithm::first_finder(Search),
> ::boost::algorithm::const_formatter(Format) );
> }
># 173 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<typename SequenceT, typename Range1T, typename Range2T>
> inline void replace_first(
> SequenceT& Input,
> const Range1T& Search,
> const Range2T& Format )
> {
> ::boost::algorithm::find_format(
> Input,
> ::boost::algorithm::first_finder(Search),
> ::boost::algorithm::const_formatter(Format) );
> }
># 205 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<
> typename OutputIteratorT,
> typename Range1T,
> typename Range2T,
> typename Range3T>
> inline OutputIteratorT ireplace_first_copy(
> OutputIteratorT Output,
> const Range1T& Input,
> const Range2T& Search,
> const Range3T& Format,
> const std::locale& Loc=std::locale() )
> {
> return ::boost::algorithm::find_format_copy(
> Output,
> Input,
> ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
> ::boost::algorithm::const_formatter(Format) );
> }
>
>
>
>
>
> template<typename SequenceT, typename Range2T, typename Range1T>
> inline SequenceT ireplace_first_copy(
> const SequenceT& Input,
> const Range2T& Search,
> const Range1T& Format,
> const std::locale& Loc=std::locale() )
> {
> return ::boost::algorithm::find_format_copy(
> Input,
> ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
> ::boost::algorithm::const_formatter(Format) );
> }
># 252 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<typename SequenceT, typename Range1T, typename Range2T>
> inline void ireplace_first(
> SequenceT& Input,
> const Range1T& Search,
> const Range2T& Format,
> const std::locale& Loc=std::locale() )
> {
> ::boost::algorithm::find_format(
> Input,
> ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
> ::boost::algorithm::const_formatter(Format) );
> }
># 283 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<
> typename OutputIteratorT,
> typename Range1T,
> typename Range2T,
> typename Range3T>
> inline OutputIteratorT replace_last_copy(
> OutputIteratorT Output,
> const Range1T& Input,
> const Range2T& Search,
> const Range3T& Format )
> {
> return ::boost::algorithm::find_format_copy(
> Output,
> Input,
> ::boost::algorithm::last_finder(Search),
> ::boost::algorithm::const_formatter(Format) );
> }
>
>
>
>
>
> template<typename SequenceT, typename Range1T, typename Range2T>
> inline SequenceT replace_last_copy(
> const SequenceT& Input,
> const Range1T& Search,
> const Range2T& Format )
> {
> return ::boost::algorithm::find_format_copy(
> Input,
> ::boost::algorithm::last_finder(Search),
> ::boost::algorithm::const_formatter(Format) );
> }
># 326 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<typename SequenceT, typename Range1T, typename Range2T>
> inline void replace_last(
> SequenceT& Input,
> const Range1T& Search,
> const Range2T& Format )
> {
> ::boost::algorithm::find_format(
> Input,
> ::boost::algorithm::last_finder(Search),
> ::boost::algorithm::const_formatter(Format) );
> }
># 358 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<
> typename OutputIteratorT,
> typename Range1T,
> typename Range2T,
> typename Range3T>
> inline OutputIteratorT ireplace_last_copy(
> OutputIteratorT Output,
> const Range1T& Input,
> const Range2T& Search,
> const Range3T& Format,
> const std::locale& Loc=std::locale() )
> {
> return ::boost::algorithm::find_format_copy(
> Output,
> Input,
> ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
> ::boost::algorithm::const_formatter(Format) );
> }
>
>
>
>
>
> template<typename SequenceT, typename Range1T, typename Range2T>
> inline SequenceT ireplace_last_copy(
> const SequenceT& Input,
> const Range1T& Search,
> const Range2T& Format,
> const std::locale& Loc=std::locale() )
> {
> return ::boost::algorithm::find_format_copy(
> Input,
> ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
> ::boost::algorithm::const_formatter(Format) );
> }
># 406 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<typename SequenceT, typename Range1T, typename Range2T>
> inline void ireplace_last(
> SequenceT& Input,
> const Range1T& Search,
> const Range2T& Format,
> const std::locale& Loc=std::locale() )
> {
> ::boost::algorithm::find_format(
> Input,
> ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
> ::boost::algorithm::const_formatter(Format) );
> }
># 439 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<
> typename OutputIteratorT,
> typename Range1T,
> typename Range2T,
> typename Range3T>
> inline OutputIteratorT replace_nth_copy(
> OutputIteratorT Output,
> const Range1T& Input,
> const Range2T& Search,
> int Nth,
> const Range3T& Format )
> {
> return ::boost::algorithm::find_format_copy(
> Output,
> Input,
> ::boost::algorithm::nth_finder(Search, Nth),
> ::boost::algorithm::const_formatter(Format) );
> }
>
>
>
>
>
> template<typename SequenceT, typename Range1T, typename Range2T>
> inline SequenceT replace_nth_copy(
> const SequenceT& Input,
> const Range1T& Search,
> int Nth,
> const Range2T& Format )
> {
> return ::boost::algorithm::find_format_copy(
> Input,
> ::boost::algorithm::nth_finder(Search, Nth),
> ::boost::algorithm::const_formatter(Format) );
> }
># 486 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<typename SequenceT, typename Range1T, typename Range2T>
> inline void replace_nth(
> SequenceT& Input,
> const Range1T& Search,
> int Nth,
> const Range2T& Format )
> {
> ::boost::algorithm::find_format(
> Input,
> ::boost::algorithm::nth_finder(Search, Nth),
> ::boost::algorithm::const_formatter(Format) );
> }
># 521 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<
> typename OutputIteratorT,
> typename Range1T,
> typename Range2T,
> typename Range3T>
> inline OutputIteratorT ireplace_nth_copy(
> OutputIteratorT Output,
> const Range1T& Input,
> const Range2T& Search,
> int Nth,
> const Range3T& Format,
> const std::locale& Loc=std::locale() )
> {
> return ::boost::algorithm::find_format_copy(
> Output,
> Input,
> ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc) ),
> ::boost::algorithm::const_formatter(Format) );
> }
>
>
>
>
>
> template<typename SequenceT, typename Range1T, typename Range2T>
> inline SequenceT ireplace_nth_copy(
> const SequenceT& Input,
> const Range1T& Search,
> int Nth,
> const Range2T& Format,
> const std::locale& Loc=std::locale() )
> {
> return ::boost::algorithm::find_format_copy(
> Input,
> ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
> ::boost::algorithm::const_formatter(Format) );
> }
># 572 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<typename SequenceT, typename Range1T, typename Range2T>
> inline void ireplace_nth(
> SequenceT& Input,
> const Range1T& Search,
> int Nth,
> const Range2T& Format,
> const std::locale& Loc=std::locale() )
> {
> ::boost::algorithm::find_format(
> Input,
> ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
> ::boost::algorithm::const_formatter(Format) );
> }
># 604 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<
> typename OutputIteratorT,
> typename Range1T,
> typename Range2T,
> typename Range3T>
> inline OutputIteratorT replace_all_copy(
> OutputIteratorT Output,
> const Range1T& Input,
> const Range2T& Search,
> const Range3T& Format )
> {
> return ::boost::algorithm::find_format_all_copy(
> Output,
> Input,
> ::boost::algorithm::first_finder(Search),
> ::boost::algorithm::const_formatter(Format) );
> }
>
>
>
>
>
> template<typename SequenceT, typename Range1T, typename Range2T>
> inline SequenceT replace_all_copy(
> const SequenceT& Input,
> const Range1T& Search,
> const Range2T& Format )
> {
> return ::boost::algorithm::find_format_all_copy(
> Input,
> ::boost::algorithm::first_finder(Search),
> ::boost::algorithm::const_formatter(Format) );
> }
># 648 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<typename SequenceT, typename Range1T, typename Range2T>
> inline void replace_all(
> SequenceT& Input,
> const Range1T& Search,
> const Range2T& Format )
> {
> ::boost::algorithm::find_format_all(
> Input,
> ::boost::algorithm::first_finder(Search),
> ::boost::algorithm::const_formatter(Format) );
> }
># 680 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<
> typename OutputIteratorT,
> typename Range1T,
> typename Range2T,
> typename Range3T>
> inline OutputIteratorT ireplace_all_copy(
> OutputIteratorT Output,
> const Range1T& Input,
> const Range2T& Search,
> const Range3T& Format,
> const std::locale& Loc=std::locale() )
> {
> return ::boost::algorithm::find_format_all_copy(
> Output,
> Input,
> ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
> ::boost::algorithm::const_formatter(Format) );
> }
>
>
>
>
>
> template<typename SequenceT, typename Range1T, typename Range2T>
> inline SequenceT ireplace_all_copy(
> const SequenceT& Input,
> const Range1T& Search,
> const Range2T& Format,
> const std::locale& Loc=std::locale() )
> {
> return ::boost::algorithm::find_format_all_copy(
> Input,
> ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
> ::boost::algorithm::const_formatter(Format) );
> }
># 727 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<typename SequenceT, typename Range1T, typename Range2T>
> inline void ireplace_all(
> SequenceT& Input,
> const Range1T& Search,
> const Range2T& Format,
> const std::locale& Loc=std::locale() )
> {
> ::boost::algorithm::find_format_all(
> Input,
> ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
> ::boost::algorithm::const_formatter(Format) );
> }
># 762 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<
> typename OutputIteratorT,
> typename Range1T,
> typename Range2T>
> inline OutputIteratorT replace_head_copy(
> OutputIteratorT Output,
> const Range1T& Input,
> int N,
> const Range2T& Format )
> {
> return ::boost::algorithm::find_format_copy(
> Output,
> Input,
> ::boost::algorithm::head_finder(N),
> ::boost::algorithm::const_formatter(Format) );
> }
>
>
>
>
>
> template<typename SequenceT, typename RangeT>
> inline SequenceT replace_head_copy(
> const SequenceT& Input,
> int N,
> const RangeT& Format )
> {
> return ::boost::algorithm::find_format_copy(
> Input,
> ::boost::algorithm::head_finder(N),
> ::boost::algorithm::const_formatter(Format) );
> }
># 808 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<typename SequenceT, typename RangeT>
> inline void replace_head(
> SequenceT& Input,
> int N,
> const RangeT& Format )
> {
> ::boost::algorithm::find_format(
> Input,
> ::boost::algorithm::head_finder(N),
> ::boost::algorithm::const_formatter(Format) );
> }
># 842 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<
> typename OutputIteratorT,
> typename Range1T,
> typename Range2T>
> inline OutputIteratorT replace_tail_copy(
> OutputIteratorT Output,
> const Range1T& Input,
> int N,
> const Range2T& Format )
> {
> return ::boost::algorithm::find_format_copy(
> Output,
> Input,
> ::boost::algorithm::tail_finder(N),
> ::boost::algorithm::const_formatter(Format) );
> }
>
>
>
>
>
> template<typename SequenceT, typename RangeT>
> inline SequenceT replace_tail_copy(
> const SequenceT& Input,
> int N,
> const RangeT& Format )
> {
> return ::boost::algorithm::find_format_copy(
> Input,
> ::boost::algorithm::tail_finder(N),
> ::boost::algorithm::const_formatter(Format) );
> }
># 888 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
> template<typename SequenceT, typename RangeT>
> inline void replace_tail(
> SequenceT& Input,
> int N,
> const RangeT& Format )
> {
> ::boost::algorithm::find_format(
> Input,
> ::boost::algorithm::tail_finder(N),
> ::boost::algorithm::const_formatter(Format) );
> }
>
> }
>
>
> using algorithm::replace_range_copy;
> using algorithm::replace_range;
> using algorithm::replace_first_copy;
> using algorithm::replace_first;
> using algorithm::ireplace_first_copy;
> using algorithm::ireplace_first;
> using algorithm::replace_last_copy;
> using algorithm::replace_last;
> using algorithm::ireplace_last_copy;
> using algorithm::ireplace_last;
> using algorithm::replace_nth_copy;
> using algorithm::replace_nth;
> using algorithm::ireplace_nth_copy;
> using algorithm::ireplace_nth;
> using algorithm::replace_all_copy;
> using algorithm::replace_all;
> using algorithm::ireplace_all_copy;
> using algorithm::ireplace_all;
> using algorithm::replace_head_copy;
> using algorithm::replace_head;
> using algorithm::replace_tail_copy;
> using algorithm::replace_tail;
>
>}
># 26 "/usr/include/boost/units/detail/utility.hpp" 2 3 4
>
>namespace boost {
>
>namespace units {
>
>namespace detail {
>
>inline
>std::string
>demangle(const char* name)
>{
>
> char* realname;
> std::size_t len;
> int stat;
>
> realname = abi::__cxa_demangle(name,__null,&len,&stat);
>
> if (realname != __null)
> {
> std::string out(realname);
>
> std::free(realname);
>
> boost::replace_all(out,"boost::units::","");
>
> return out;
> }
>
> return std::string("demangle :: error - unable to demangle specified symbol");
>}
>
>}
>
>template<class L>
>std::string simplify_typename(const L& )
>{
> const std::string demangled = detail::demangle(typeid(L).name());
>
> return demangled;
>}
>
>}
>
>}
># 20 "/usr/include/boost/exception/detail/type_info.hpp" 2 3
>
>
>
>namespace
>boost
> {
> template <class T>
> inline
> std::string
> tag_type_name()
> {
>
>
>
> return units::detail::demangle(typeid(T*).name());
>
> }
>
> template <class T>
> inline
> std::string
> type_name()
> {
>
>
>
> return units::detail::demangle(typeid(T).name());
>
> }
>
> namespace
> exception_detail
> {
> struct
> type_info_
> {
> detail::sp_typeinfo const * type_;
>
> explicit
> type_info_( detail::sp_typeinfo const & type ):
> type_(&type)
> {
> }
>
> friend
> bool
> operator<( type_info_ const & a, type_info_ const & b )
> {
> return 0!=(a.type_->before(*b.type_));
> }
> };
> }
> }
># 16 "/usr/include/boost/exception/detail/object_hex_dump.hpp" 2 3
># 1 "/usr/include/c++/4.8.2/iomanip" 1 3
># 36 "/usr/include/c++/4.8.2/iomanip" 3
> 
># 37 "/usr/include/c++/4.8.2/iomanip" 3
># 46 "/usr/include/c++/4.8.2/iomanip" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
> struct _Resetiosflags { ios_base::fmtflags _M_mask; };
># 62 "/usr/include/c++/4.8.2/iomanip" 3
> inline _Resetiosflags
> resetiosflags(ios_base::fmtflags __mask)
> { return { __mask }; }
>
> template<typename _CharT, typename _Traits>
> inline basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f)
> {
> __is.setf(ios_base::fmtflags(0), __f._M_mask);
> return __is;
> }
>
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f)
> {
> __os.setf(ios_base::fmtflags(0), __f._M_mask);
> return __os;
> }
>
>
> struct _Setiosflags { ios_base::fmtflags _M_mask; };
># 92 "/usr/include/c++/4.8.2/iomanip" 3
> inline _Setiosflags
> setiosflags(ios_base::fmtflags __mask)
> { return { __mask }; }
>
> template<typename _CharT, typename _Traits>
> inline basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f)
> {
> __is.setf(__f._M_mask);
> return __is;
> }
>
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f)
> {
> __os.setf(__f._M_mask);
> return __os;
> }
>
>
> struct _Setbase { int _M_base; };
># 123 "/usr/include/c++/4.8.2/iomanip" 3
> inline _Setbase
> setbase(int __base)
> { return { __base }; }
>
> template<typename _CharT, typename _Traits>
> inline basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f)
> {
> __is.setf(__f._M_base == 8 ? ios_base::oct :
> __f._M_base == 10 ? ios_base::dec :
> __f._M_base == 16 ? ios_base::hex :
> ios_base::fmtflags(0), ios_base::basefield);
> return __is;
> }
>
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f)
> {
> __os.setf(__f._M_base == 8 ? ios_base::oct :
> __f._M_base == 10 ? ios_base::dec :
> __f._M_base == 16 ? ios_base::hex :
> ios_base::fmtflags(0), ios_base::basefield);
> return __os;
> }
>
>
> template<typename _CharT>
> struct _Setfill { _CharT _M_c; };
># 160 "/usr/include/c++/4.8.2/iomanip" 3
> template<typename _CharT>
> inline _Setfill<_CharT>
> setfill(_CharT __c)
> { return { __c }; }
>
> template<typename _CharT, typename _Traits>
> inline basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f)
> {
> __is.fill(__f._M_c);
> return __is;
> }
>
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f)
> {
> __os.fill(__f._M_c);
> return __os;
> }
>
>
> struct _Setprecision { int _M_n; };
># 191 "/usr/include/c++/4.8.2/iomanip" 3
> inline _Setprecision
> setprecision(int __n)
> { return { __n }; }
>
> template<typename _CharT, typename _Traits>
> inline basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f)
> {
> __is.precision(__f._M_n);
> return __is;
> }
>
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f)
> {
> __os.precision(__f._M_n);
> return __os;
> }
>
>
> struct _Setw { int _M_n; };
># 221 "/usr/include/c++/4.8.2/iomanip" 3
> inline _Setw
> setw(int __n)
> { return { __n }; }
>
> template<typename _CharT, typename _Traits>
> inline basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f)
> {
> __is.width(__f._M_n);
> return __is;
> }
>
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f)
> {
> __os.width(__f._M_n);
> return __os;
> }
>
>
>
> template<typename _MoneyT>
> struct _Get_money { _MoneyT& _M_mon; bool _M_intl; };
># 254 "/usr/include/c++/4.8.2/iomanip" 3
> template<typename _MoneyT>
> inline _Get_money<_MoneyT>
> get_money(_MoneyT& __mon, bool __intl = false)
> { return { __mon, __intl }; }
>
> template<typename _CharT, typename _Traits, typename _MoneyT>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __is, _Get_money<_MoneyT> __f)
> {
> typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> typedef istreambuf_iterator<_CharT, _Traits> _Iter;
> typedef money_get<_CharT, _Iter> _MoneyGet;
>
> const _MoneyGet& __mg = use_facet<_MoneyGet>(__is.getloc());
> __mg.get(_Iter(__is.rdbuf()), _Iter(), __f._M_intl,
> __is, __err, __f._M_mon);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __is._M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { __is._M_setstate(ios_base::badbit); }
> if (__err)
> __is.setstate(__err);
> }
> return __is;
> }
>
>
> template<typename _MoneyT>
> struct _Put_money { const _MoneyT& _M_mon; bool _M_intl; };
># 301 "/usr/include/c++/4.8.2/iomanip" 3
> template<typename _MoneyT>
> inline _Put_money<_MoneyT>
> put_money(const _MoneyT& __mon, bool __intl = false)
> { return { __mon, __intl }; }
>
> template<typename _CharT, typename _Traits, typename _MoneyT>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f)
> {
> typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> typedef ostreambuf_iterator<_CharT, _Traits> _Iter;
> typedef money_put<_CharT, _Iter> _MoneyPut;
>
> const _MoneyPut& __mp = use_facet<_MoneyPut>(__os.getloc());
> if (__mp.put(_Iter(__os.rdbuf()), __f._M_intl, __os,
> __os.fill(), __f._M_mon).failed())
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __os._M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { __os._M_setstate(ios_base::badbit); }
> if (__err)
> __os.setstate(__err);
> }
> return __os;
> }
>
>
>
>
>
>
>
> extern template ostream& operator<<(ostream&, _Setfill<char>);
> extern template ostream& operator<<(ostream&, _Setiosflags);
> extern template ostream& operator<<(ostream&, _Resetiosflags);
> extern template ostream& operator<<(ostream&, _Setbase);
> extern template ostream& operator<<(ostream&, _Setprecision);
> extern template ostream& operator<<(ostream&, _Setw);
> extern template istream& operator>>(istream&, _Setfill<char>);
> extern template istream& operator>>(istream&, _Setiosflags);
> extern template istream& operator>>(istream&, _Resetiosflags);
> extern template istream& operator>>(istream&, _Setbase);
> extern template istream& operator>>(istream&, _Setprecision);
> extern template istream& operator>>(istream&, _Setw);
>
>
> extern template wostream& operator<<(wostream&, _Setfill<wchar_t>);
> extern template wostream& operator<<(wostream&, _Setiosflags);
> extern template wostream& operator<<(wostream&, _Resetiosflags);
> extern template wostream& operator<<(wostream&, _Setbase);
> extern template wostream& operator<<(wostream&, _Setprecision);
> extern template wostream& operator<<(wostream&, _Setw);
> extern template wistream& operator>>(wistream&, _Setfill<wchar_t>);
> extern template wistream& operator>>(wistream&, _Setiosflags);
> extern template wistream& operator>>(wistream&, _Resetiosflags);
> extern template wistream& operator>>(wistream&, _Setbase);
> extern template wistream& operator>>(wistream&, _Setprecision);
> extern template wistream& operator>>(wistream&, _Setw);
>
>
>
>
>}
># 17 "/usr/include/boost/exception/detail/object_hex_dump.hpp" 2 3
>
>
>
># 1 "/usr/include/c++/4.8.2/cstdlib" 1 3
># 39 "/usr/include/c++/4.8.2/cstdlib" 3
> 
># 40 "/usr/include/c++/4.8.2/cstdlib" 3
># 21 "/usr/include/boost/exception/detail/object_hex_dump.hpp" 2 3
>
>namespace
>boost
> {
> namespace
> exception_detail
> {
> template <class T>
> inline
> std::string
> object_hex_dump( T const & x, std::size_t max_size=16 )
> {
> std::ostringstream s;
> s << "type: " << type_name<T>() << ", size: " << sizeof(T) << ", dump: ";
> std::size_t n=sizeof(T)>max_size?max_size:sizeof(T);
> s.fill('0');
> s.width(2);
> unsigned char const * b=reinterpret_cast<unsigned char const *>(&x);
> s << std::setw(2) << std::hex << (unsigned int)*b;
> for( unsigned char const * e=b+n; ++b!=e; )
> s << " " << std::setw(2) << std::hex << (unsigned int)*b;
> return s.str();
> }
> }
> }
># 17 "/usr/include/boost/exception/to_string_stub.hpp" 2 3
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 18 "/usr/include/boost/exception/to_string_stub.hpp" 2 3
>
>namespace
>boost
> {
> namespace
> exception_detail
> {
> template <bool ToStringAvailable>
> struct
> to_string_dispatcher
> {
> template <class T,class Stub>
> static
> std::string
> convert( T const & x, Stub )
> {
> return to_string(x);
> }
> };
>
> template <>
> struct
> to_string_dispatcher<false>
> {
> template <class T,class Stub>
> static
> std::string
> convert( T const & x, Stub s )
> {
> return s(x);
> }
>
> template <class T>
> static
> std::string
> convert( T const & x, std::string s )
> {
> return s;
> }
>
> template <class T>
> static
> std::string
> convert( T const & x, char const * s )
> {
> ((void)0);
> return s;
> }
> };
>
> namespace
> to_string_dispatch
> {
> template <class T,class Stub>
> inline
> std::string
> dispatch( T const & x, Stub s )
> {
> return to_string_dispatcher<has_to_string<T>::value>::convert(x,s);
> }
> }
>
> template <class T>
> inline
> std::string
> string_stub_dump( T const & x )
> {
> return "[ " + exception_detail::object_hex_dump(x) + " ]";
> }
> }
>
> template <class T>
> inline
> std::string
> to_string_stub( T const & x )
> {
> return exception_detail::to_string_dispatch::dispatch(x,&exception_detail::string_stub_dump<T>);
> }
>
> template <class T,class Stub>
> inline
> std::string
> to_string_stub( T const & x, Stub s )
> {
> return exception_detail::to_string_dispatch::dispatch(x,s);
> }
>
> template <class T,class U,class Stub>
> inline
> std::string
> to_string_stub( std::pair<T,U> const & x, Stub s )
> {
> return std::string("(") + to_string_stub(x.first,s) + ',' + to_string_stub(x.second,s) + ')';
> }
> }
># 17 "/usr/include/boost/exception/info.hpp" 2 3
># 1 "/usr/include/boost/exception/detail/error_info_impl.hpp" 1 3 4
># 9 "/usr/include/boost/exception/detail/error_info_impl.hpp" 3 4
> 
># 10 "/usr/include/boost/exception/detail/error_info_impl.hpp" 3
>
>
>
>
>
>
>
>namespace
>boost
> {
> namespace
> exception_detail
> {
> class
> error_info_base
> {
> public:
>
> virtual std::string name_value_string() const = 0;
>
> protected:
>
> virtual
> ~error_info_base() throw()
> {
> }
> };
> }
>
> template <class Tag,class T>
> class
> error_info:
> public exception_detail::error_info_base
> {
> public:
>
> typedef T value_type;
>
> error_info( value_type const & value );
> ~error_info() throw();
>
> value_type const &
> value() const
> {
> return value_;
> }
>
> value_type &
> value()
> {
> return value_;
> }
>
> private:
>
> std::string name_value_string() const;
>
> value_type value_;
> };
> }
># 18 "/usr/include/boost/exception/info.hpp" 2 3
>
>
>
>
>namespace
>boost
> {
> template <class Tag,class T>
> inline
> std::string
> error_info_name( error_info<Tag,T> const & x )
> {
> return tag_type_name<Tag>();
> }
>
> template <class Tag,class T>
> inline
> std::string
> to_string( error_info<Tag,T> const & x )
> {
> return '[' + error_info_name(x) + "] = " + to_string_stub(x.value()) + '\n';
> }
>
> template <class Tag,class T>
> inline
> error_info<Tag,T>::
> error_info( value_type const & value ):
> value_(value)
> {
> }
>
> template <class Tag,class T>
> inline
> error_info<Tag,T>::
> ~error_info() throw()
> {
> }
>
> template <class Tag,class T>
> inline
> std::string
> error_info<Tag,T>::
> name_value_string() const
> {
> return to_string_stub(*this);
> }
>
> namespace
> exception_detail
> {
> class
> error_info_container_impl:
> public error_info_container
> {
> public:
>
> error_info_container_impl():
> count_(0)
> {
> }
>
> ~error_info_container_impl() throw()
> {
> }
>
> void
> set( shared_ptr<error_info_base> const & x, type_info_ const & typeid_ )
> {
> ((void)0);
> info_[typeid_] = x;
> diagnostic_info_str_.clear();
> }
>
> shared_ptr<error_info_base>
> get( type_info_ const & ti ) const
> {
> error_info_map::const_iterator i=info_.find(ti);
> if( info_.end()!=i )
> {
> shared_ptr<error_info_base> const & p = i->second;
>
> ((void)0);
>
> return p;
> }
> return shared_ptr<error_info_base>();
> }
>
> char const *
> diagnostic_information( char const * header ) const
> {
> if( header )
> {
> std::ostringstream tmp;
> tmp << header;
> for( error_info_map::const_iterator i=info_.begin(),end=info_.end(); i!=end; ++i )
> {
> error_info_base const & x = *i->second;
> tmp << x.name_value_string();
> }
> tmp.str().swap(diagnostic_info_str_);
> }
> return diagnostic_info_str_.c_str();
> }
>
> private:
>
> friend class boost::exception;
>
> typedef std::map< type_info_, shared_ptr<error_info_base> > error_info_map;
> error_info_map info_;
> mutable std::string diagnostic_info_str_;
> mutable int count_;
>
> error_info_container_impl( error_info_container_impl const & );
> error_info_container_impl & operator=( error_info_container const & );
>
> void
> add_ref() const
> {
> ++count_;
> }
>
> bool
> release() const
> {
> if( --count_ )
> return false;
> else
> {
> delete this;
> return true;
> }
> }
>
> refcount_ptr<error_info_container>
> clone() const
> {
> refcount_ptr<error_info_container> p;
> error_info_container_impl * c=new error_info_container_impl;
> p.adopt(c);
> c->info_ = info_;
> return p;
> }
> };
>
> template <class E,class Tag,class T>
> inline
> E const &
> set_info( E const & x, error_info<Tag,T> const & v )
> {
> typedef error_info<Tag,T> error_info_tag_t;
> shared_ptr<error_info_tag_t> p( new error_info_tag_t(v) );
> exception_detail::error_info_container * c=x.data_.get();
> if( !c )
> x.data_.adopt(c=new exception_detail::error_info_container_impl);
> c->set(p,::boost::exception_detail::type_info_(typeid(error_info_tag_t)));
> return x;
> }
>
> template <class T>
> struct
> derives_boost_exception
> {
> enum e { value = (sizeof(dispatch_boost_exception((T*)0))==sizeof(large_size)) };
> };
> }
>
> template <class E,class Tag,class T>
> inline
> typename enable_if<exception_detail::derives_boost_exception<E>,E const &>::type
> operator<<( E const & x, error_info<Tag,T> const & v )
> {
> return exception_detail::set_info(x,v);
> }
> }
># 21 "/usr/include/boost/exception/detail/exception_ptr.hpp" 2 3
># 1 "/usr/include/boost/exception/diagnostic_information.hpp" 1 3 4
># 9 "/usr/include/boost/exception/diagnostic_information.hpp" 3 4
> 
># 10 "/usr/include/boost/exception/diagnostic_information.hpp" 3
>
>
>
>
>
>
># 1 "/usr/include/boost/exception/get_error_info.hpp" 1 3 4
># 9 "/usr/include/boost/exception/get_error_info.hpp" 3 4
> 
># 10 "/usr/include/boost/exception/get_error_info.hpp" 3
># 20 "/usr/include/boost/exception/get_error_info.hpp" 3
>namespace
>boost
> {
> namespace
> exception_detail
> {
> template <class ErrorInfo>
> struct
> get_info
> {
> static
> typename ErrorInfo::value_type *
> get( exception const & x )
> {
> if( exception_detail::error_info_container * c=x.data_.get() )
> if( shared_ptr<exception_detail::error_info_base> eib = c->get(::boost::exception_detail::type_info_(typeid(ErrorInfo))) )
> {
>
> ((void)0);
>
> ErrorInfo * w = static_cast<ErrorInfo *>(eib.get());
> return &w->value();
> }
> return 0;
> }
> };
>
> template <>
> struct
> get_info<throw_function>
> {
> static
> char const * *
> get( exception const & x )
> {
> return x.throw_function_ ? &x.throw_function_ : 0;
> }
> };
>
> template <>
> struct
> get_info<throw_file>
> {
> static
> char const * *
> get( exception const & x )
> {
> return x.throw_file_ ? &x.throw_file_ : 0;
> }
> };
>
> template <>
> struct
> get_info<throw_line>
> {
> static
> int *
> get( exception const & x )
> {
> return x.throw_line_!=-1 ? &x.throw_line_ : 0;
> }
> };
>
> template <class T,class R>
> struct
> get_error_info_return_type
> {
> typedef R * type;
> };
>
> template <class T,class R>
> struct
> get_error_info_return_type<T const,R>
> {
> typedef R const * type;
> };
> }
># 114 "/usr/include/boost/exception/get_error_info.hpp" 3
> template <class ErrorInfo,class E>
> inline
> typename exception_detail::get_error_info_return_type<E,typename ErrorInfo::value_type>::type
> get_error_info( E & some_exception )
> {
> if( exception const * x = dynamic_cast<exception const *>(&some_exception) )
> return exception_detail::get_info<ErrorInfo>::get(*x);
> else
> return 0;
> }
>
> }
># 17 "/usr/include/boost/exception/diagnostic_information.hpp" 2 3
># 27 "/usr/include/boost/exception/diagnostic_information.hpp" 3
># 1 "/usr/include/boost/exception/current_exception_cast.hpp" 1 3 4
># 9 "/usr/include/boost/exception/current_exception_cast.hpp" 3 4
> 
># 10 "/usr/include/boost/exception/current_exception_cast.hpp" 3
>
>
>
>
>
>namespace
>boost
> {
> template <class E>
> inline
> E *
> current_exception_cast()
> {
> try
> {
> throw;
> }
> catch(
> E & e )
> {
> return &e;
> }
> catch(
> ...)
> {
> return 0;
> }
> }
> }
># 28 "/usr/include/boost/exception/diagnostic_information.hpp" 2 3
>namespace
>boost
> {
> namespace
> exception_detail
> {
> std::string diagnostic_information_impl( boost::exception const *, std::exception const *, bool, bool );
> }
>
> inline
> std::string
> current_exception_diagnostic_information( bool verbose=true)
> {
> boost::exception const * be=current_exception_cast<boost::exception const>();
> std::exception const * se=current_exception_cast<std::exception const>();
> if( be || se )
> return exception_detail::diagnostic_information_impl(be,se,true,verbose);
> else
> return "No diagnostic information available.";
> }
> }
>
>
>namespace
>boost
> {
> namespace
> exception_detail
> {
> inline
> exception const *
> get_boost_exception( exception const * e )
> {
> return e;
> }
>
> inline
> exception const *
> get_boost_exception( ... )
> {
> return 0;
> }
>
> inline
> std::exception const *
> get_std_exception( std::exception const * e )
> {
> return e;
> }
>
> inline
> std::exception const *
> get_std_exception( ... )
> {
> return 0;
> }
>
> inline
> char const *
> get_diagnostic_information( exception const & x, char const * header )
> {
>
> try
> {
>
> error_info_container * c=x.data_.get();
> if( !c )
> x.data_.adopt(c=new exception_detail::error_info_container_impl);
> char const * di=c->diagnostic_information(header);
> ((void)0);
> return di;
>
> }
> catch(...)
> {
> return 0;
> }
>
> }
>
> inline
> std::string
> diagnostic_information_impl( boost::exception const * be, std::exception const * se, bool with_what, bool verbose )
> {
> if( !be && !se )
> return "Unknown exception.";
>
> if( !be )
> be=dynamic_cast<boost::exception const *>(se);
> if( !se )
> se=dynamic_cast<std::exception const *>(be);
>
> char const * wh=0;
> if( with_what && se )
> {
> wh=se->what();
> if( be && exception_detail::get_diagnostic_information(*be,0)==wh )
> return wh;
> }
> std::ostringstream tmp;
> if( be && verbose )
> {
> char const * const * f=get_error_info<throw_file>(*be);
> int const * l=get_error_info<throw_line>(*be);
> char const * const * fn=get_error_info<throw_function>(*be);
> if( !f && !l && !fn )
> tmp << "Throw location unknown (consider using BOOST_THROW_EXCEPTION)\n";
> else
> {
> if( f )
> {
> tmp << *f;
> if( int const * l=get_error_info<throw_line>(*be) )
> tmp << '(' << *l << "): ";
> }
> tmp << "Throw in function ";
> if( char const * const * fn=get_error_info<throw_function>(*be) )
> tmp << *fn;
> else
> tmp << "(unknown)";
> tmp << '\n';
> }
> }
>
> if ( verbose )
> tmp << std::string("Dynamic exception type: ") <<
> units::detail::demangle((be?(::boost::exception_detail::type_info_(typeid(*be))):(::boost::exception_detail::type_info_(typeid(*se)))).type_->name()) << '\n';
>
> if( with_what && se && verbose )
> tmp << "std::exception::what: " << wh << '\n';
> if( be )
> if( char const * s=exception_detail::get_diagnostic_information(*be,tmp.str().c_str()) )
> if( *s )
> return std::string(s);
> return tmp.str();
> }
> }
>
> template <class T>
> std::string
> diagnostic_information( T const & e, bool verbose=true )
> {
> return exception_detail::diagnostic_information_impl(exception_detail::get_boost_exception(&e),exception_detail::get_std_exception(&e),true,verbose);
> }
>
> inline
> char const *
> diagnostic_information_what( exception const & e, bool verbose=true ) throw()
> {
> char const * w=0;
>
> try
> {
>
> (void) exception_detail::diagnostic_information_impl(&e,0,false,verbose);
> if( char const * di=exception_detail::get_diagnostic_information(e,0) )
> return di;
> else
> return "Failed to produce boost::diagnostic_information_what()";
>
> }
> catch(
> ... )
> {
> }
>
> return w;
> }
> }
># 22 "/usr/include/boost/exception/detail/exception_ptr.hpp" 2 3
>
># 1 "/usr/include/boost/exception/detail/clone_current_exception.hpp" 1 3 4
># 13 "/usr/include/boost/exception/detail/clone_current_exception.hpp" 3 4
>namespace
>boost
> {
> namespace
> exception_detail
> {
> class clone_base;
>
>
>
>
>
> namespace
> clone_current_exception_result
> {
> int const success=0;
> int const bad_alloc=1;
> int const bad_exception=2;
> int const not_supported=3;
> }
>
> inline
> int
> clone_current_exception( clone_base const * & cloned )
> {
>
>
>
> return clone_current_exception_result::not_supported;
>
> }
> }
> }
># 24 "/usr/include/boost/exception/detail/exception_ptr.hpp" 2 3
>
>
>
>
>
>
>namespace
>boost
> {
> class exception_ptr;
> __attribute__((__noreturn__)) void rethrow_exception( exception_ptr const & );
> exception_ptr current_exception();
>
> class
> exception_ptr
> {
> typedef boost::shared_ptr<exception_detail::clone_base const> impl;
> impl ptr_;
> friend void rethrow_exception( exception_ptr const & );
> typedef exception_detail::clone_base const * (impl::*unspecified_bool_type)() const;
> public:
> exception_ptr()
> {
> }
> explicit
> exception_ptr( impl const & ptr ):
> ptr_(ptr)
> {
> }
> bool
> operator==( exception_ptr const & other ) const
> {
> return ptr_==other.ptr_;
> }
> bool
> operator!=( exception_ptr const & other ) const
> {
> return ptr_!=other.ptr_;
> }
> operator unspecified_bool_type() const
> {
> return ptr_?&impl::get:0;
> }
> };
>
> template <class T>
> inline
> exception_ptr
> copy_exception( T const & e )
> {
> try
> {
> throw enable_current_exception(e);
> }
> catch(
> ... )
> {
> return current_exception();
> }
> }
>
>
> typedef error_info<struct tag_original_exception_type,std::type_info const *> original_exception_type;
>
> inline
> std::string
> to_string( original_exception_type const & x )
> {
> return x.value()->name();
> }
>
>
> namespace
> exception_detail
> {
> struct
> bad_alloc_:
> boost::exception,
> std::bad_alloc
> {
> ~bad_alloc_() throw() { }
> };
>
> struct
> bad_exception_:
> boost::exception,
> std::bad_exception
> {
> ~bad_exception_() throw() { }
> };
>
> template <class Exception>
> exception_ptr
> get_static_exception_object()
> {
> Exception ba;
> exception_detail::clone_impl<Exception> c(ba);
> c <<
> throw_function(__PRETTY_FUNCTION__) <<
> throw_file("/usr/include/boost/exception/detail/exception_ptr.hpp") <<
> throw_line(124);
> static exception_ptr ep(shared_ptr<exception_detail::clone_base const>(new exception_detail::clone_impl<Exception>(c)));
> return ep;
> }
>
> template <class Exception>
> struct
> exception_ptr_static_exception_object
> {
> static exception_ptr const e;
> };
>
> template <class Exception>
> exception_ptr const
> exception_ptr_static_exception_object<Exception>::
> e = get_static_exception_object<Exception>();
> }
>
>
>
>#pragma GCC visibility push (default)
>
>
> class
> unknown_exception:
> public boost::exception,
> public std::exception
> {
> public:
>
> unknown_exception()
> {
> }
>
> explicit
> unknown_exception( std::exception const & e )
> {
> add_original_type(e);
> }
>
> explicit
> unknown_exception( boost::exception const & e ):
> boost::exception(e)
> {
> add_original_type(e);
> }
>
> ~unknown_exception() throw()
> {
> }
>
> private:
>
> template <class E>
> void
> add_original_type( E const & e )
> {
>
> (*this) << original_exception_type(&typeid(e));
>
> }
> };
>
>
>#pragma GCC visibility pop
>
>
>
> namespace
> exception_detail
> {
> template <class T>
> class
> current_exception_std_exception_wrapper:
> public T,
> public boost::exception
> {
> public:
>
> explicit
> current_exception_std_exception_wrapper( T const & e1 ):
> T(e1)
> {
> add_original_type(e1);
> }
>
> current_exception_std_exception_wrapper( T const & e1, boost::exception const & e2 ):
> T(e1),
> boost::exception(e2)
> {
> add_original_type(e1);
> }
>
> ~current_exception_std_exception_wrapper() throw()
> {
> }
>
> private:
>
> template <class E>
> void
> add_original_type( E const & e )
> {
>
> (*this) << original_exception_type(&typeid(e));
>
> }
> };
># 253 "/usr/include/boost/exception/detail/exception_ptr.hpp" 3
> template <class T>
> boost::exception const *
> get_boost_exception( T const * x )
> {
> return dynamic_cast<boost::exception const *>(x);
> }
>
>
> template <class T>
> inline
> exception_ptr
> current_exception_std_exception( T const & e1 )
> {
> if( boost::exception const * e2 = get_boost_exception(&e1) )
> return boost::copy_exception(current_exception_std_exception_wrapper<T>(e1,*e2));
> else
> return boost::copy_exception(current_exception_std_exception_wrapper<T>(e1));
> }
>
> inline
> exception_ptr
> current_exception_unknown_exception()
> {
> return boost::copy_exception(unknown_exception());
> }
>
> inline
> exception_ptr
> current_exception_unknown_boost_exception( boost::exception const & e )
> {
> return boost::copy_exception(unknown_exception(e));
> }
>
> inline
> exception_ptr
> current_exception_unknown_std_exception( std::exception const & e )
> {
> if( boost::exception const * be = get_boost_exception(&e) )
> return current_exception_unknown_boost_exception(*be);
> else
> return boost::copy_exception(unknown_exception(e));
> }
>
> inline
> exception_ptr
> current_exception_impl()
> {
> exception_detail::clone_base const * e=0;
> switch(
> exception_detail::clone_current_exception(e) )
> {
> case exception_detail::clone_current_exception_result::
> success:
> {
> ((void)0);
> return exception_ptr(shared_ptr<exception_detail::clone_base const>(e));
> }
> case exception_detail::clone_current_exception_result::
> bad_alloc:
> {
> ((void)0);
> return exception_detail::exception_ptr_static_exception_object<bad_alloc_>::e;
> }
> case exception_detail::clone_current_exception_result::
> bad_exception:
> {
> ((void)0);
> return exception_detail::exception_ptr_static_exception_object<bad_exception_>::e;
> }
> default:
> ((void)0);
> case exception_detail::clone_current_exception_result::
> not_supported:
> {
> ((void)0);
> try
> {
> throw;
> }
> catch(
> exception_detail::clone_base & e )
> {
> return exception_ptr(shared_ptr<exception_detail::clone_base const>(e.clone()));
> }
> catch(
> std::domain_error & e )
> {
> return exception_detail::current_exception_std_exception(e);
> }
> catch(
> std::invalid_argument & e )
> {
> return exception_detail::current_exception_std_exception(e);
> }
> catch(
> std::length_error & e )
> {
> return exception_detail::current_exception_std_exception(e);
> }
> catch(
> std::out_of_range & e )
> {
> return exception_detail::current_exception_std_exception(e);
> }
> catch(
> std::logic_error & e )
> {
> return exception_detail::current_exception_std_exception(e);
> }
> catch(
> std::range_error & e )
> {
> return exception_detail::current_exception_std_exception(e);
> }
> catch(
> std::overflow_error & e )
> {
> return exception_detail::current_exception_std_exception(e);
> }
> catch(
> std::underflow_error & e )
> {
> return exception_detail::current_exception_std_exception(e);
> }
> catch(
> std::ios_base::failure & e )
> {
> return exception_detail::current_exception_std_exception(e);
> }
> catch(
> std::runtime_error & e )
> {
> return exception_detail::current_exception_std_exception(e);
> }
> catch(
> std::bad_alloc & e )
> {
> return exception_detail::current_exception_std_exception(e);
> }
>
> catch(
> std::bad_cast & e )
> {
> return exception_detail::current_exception_std_exception(e);
> }
> catch(
> std::bad_typeid & e )
> {
> return exception_detail::current_exception_std_exception(e);
> }
>
> catch(
> std::bad_exception & e )
> {
> return exception_detail::current_exception_std_exception(e);
> }
> catch(
> std::exception & e )
> {
> return exception_detail::current_exception_unknown_std_exception(e);
> }
> catch(
> boost::exception & e )
> {
> return exception_detail::current_exception_unknown_boost_exception(e);
> }
> catch(
> ... )
> {
> return exception_detail::current_exception_unknown_exception();
> }
> }
> }
> }
> }
>
> inline
> exception_ptr
> current_exception()
> {
> exception_ptr ret;
> try
> {
> ret=exception_detail::current_exception_impl();
> }
> catch(
> std::bad_alloc & )
> {
> ret=exception_detail::exception_ptr_static_exception_object<exception_detail::bad_alloc_>::e;
> }
> catch(
> ... )
> {
> ret=exception_detail::exception_ptr_static_exception_object<exception_detail::bad_exception_>::e;
> }
> ((void)0);
> return ret;
> }
>
> __attribute__((__noreturn__))
> inline
> void
> rethrow_exception( exception_ptr const & p )
> {
> ((void)0);
> p.ptr_->rethrow();
> ((void)0);
>
>
>
>
> abort();
>
> }
>
> inline
> std::string
> diagnostic_information( exception_ptr const & p, bool verbose=true )
> {
> if( p )
> try
> {
> rethrow_exception(p);
> }
> catch(
> ... )
> {
> return current_exception_diagnostic_information(verbose);
> }
> return "<empty>";
> }
>
> inline
> std::string
> to_string( exception_ptr const & p )
> {
> std::string s='\n'+diagnostic_information(p);
> std::string padding(" ");
> std::string r;
> bool f=false;
> for( std::string::const_iterator i=s.begin(),e=s.end(); i!=e; ++i )
> {
> if( f )
> r+=padding;
> char c=*i;
> r+=c;
> f=(c=='\n');
> }
> return r;
> }
> }
># 10 "/usr/include/boost/exception_ptr.hpp" 2 3 4
># 29 "/usr/include/boost/thread/future.hpp" 2 3 4
>
># 1 "/usr/include/boost/scoped_ptr.hpp" 1 3 4
># 14 "/usr/include/boost/scoped_ptr.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 1 3 4
># 15 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 16 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 2 3 4
># 24 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 3 4
>namespace boost
>{
># 41 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 3 4
>template<class T> class scoped_ptr
>{
>private:
>
> T * px;
>
> scoped_ptr(scoped_ptr const &);
> scoped_ptr & operator=(scoped_ptr const &);
>
> typedef scoped_ptr<T> this_type;
>
> void operator==( scoped_ptr const& ) const;
> void operator!=( scoped_ptr const& ) const;
>
>public:
>
> typedef T element_type;
>
> explicit scoped_ptr( T * p = 0 ): px( p )
> {
>
>
>
> }
>
>
>
> explicit scoped_ptr( std::auto_ptr<T> p ) noexcept : px( p.release() )
> {
>
>
>
> }
>
>
>
> ~scoped_ptr()
> {
>
>
>
> boost::checked_delete( px );
> }
>
> void reset(T * p = 0)
> {
> ((void)0);
> this_type(p).swap(*this);
> }
>
> T & operator*() const
> {
> ((void)0);
> return *px;
> }
>
> T * operator->() const
> {
> ((void)0);
> return px;
> }
>
> T * get() const noexcept
> {
> return px;
> }
>
>
># 1 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 1 3 4
># 11 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
> explicit operator bool () const noexcept
> {
> return px != 0;
> }
># 60 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
> bool operator! () const noexcept
> {
> return px == 0;
> }
># 110 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 2 3 4
>
> void swap(scoped_ptr & b) noexcept
> {
> T * tmp = b.px;
> b.px = px;
> px = tmp;
> }
>};
>
>
>
>template<class T> inline bool operator==( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
>{
> return p.get() == 0;
>}
>
>template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) noexcept
>{
> return p.get() == 0;
>}
>
>template<class T> inline bool operator!=( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
>{
> return p.get() != 0;
>}
>
>template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) noexcept
>{
> return p.get() != 0;
>}
>
>
>
>template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) noexcept
>{
> a.swap(b);
>}
>
>
>
>template<class T> inline T * get_pointer(scoped_ptr<T> const & p) noexcept
>{
> return p.get();
>}
>
>}
># 15 "/usr/include/boost/scoped_ptr.hpp" 2 3 4
># 31 "/usr/include/boost/thread/future.hpp" 2 3 4
># 39 "/usr/include/boost/thread/future.hpp" 3 4
># 1 "/usr/include/boost/function.hpp" 1 3 4
># 15 "/usr/include/boost/function.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/iterate.hpp" 1 3 4
># 16 "/usr/include/boost/function.hpp" 2 3 4
># 24 "/usr/include/boost/function.hpp" 3 4
># 1 "/usr/include/boost/function/detail/prologue.hpp" 1 3 4
># 12 "/usr/include/boost/function/detail/prologue.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cassert" 1 3 4
># 41 "/usr/include/c++/4.8.2/cassert" 3 4
> 
># 42 "/usr/include/c++/4.8.2/cassert" 3
>
># 1 "/usr/include/assert.h" 1 3 4
># 64 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (const char *__assertion, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 43 "/usr/include/c++/4.8.2/cassert" 2 3
># 13 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
>
># 1 "/usr/include/boost/config/no_tr1/functional.hpp" 1 3 4
># 15 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/function/function_base.hpp" 1 3 4
># 20 "/usr/include/boost/function/function_base.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 21 "/usr/include/boost/function/function_base.hpp" 2 3 4
># 1 "/usr/include/boost/integer.hpp" 1 3 4
># 22 "/usr/include/boost/integer.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 23 "/usr/include/boost/integer.hpp" 2 3 4
># 34 "/usr/include/boost/integer.hpp" 3 4
> 
># 35 "/usr/include/boost/integer.hpp" 3
>
>
>namespace boost
>{
>
>
>
>
>
> template< typename LeastInt >
> struct int_fast_t
> {
> typedef LeastInt fast;
> typedef fast type;
> };
>
> namespace detail{
>
>
> template< int Category > struct int_least_helper {};
> template< int Category > struct uint_least_helper {};
>
>
>
>
>
> template<> struct int_least_helper<1> { typedef boost::long_long_type least; };
>
>
>
> template<> struct int_least_helper<2> { typedef long least; };
> template<> struct int_least_helper<3> { typedef int least; };
> template<> struct int_least_helper<4> { typedef short least; };
> template<> struct int_least_helper<5> { typedef signed char least; };
>
> template<> struct uint_least_helper<1> { typedef boost::ulong_long_type least; };
>
>
>
> template<> struct uint_least_helper<2> { typedef unsigned long least; };
> template<> struct uint_least_helper<3> { typedef unsigned int least; };
> template<> struct uint_least_helper<4> { typedef unsigned short least; };
> template<> struct uint_least_helper<5> { typedef unsigned char least; };
>
> template <int Bits>
> struct exact_signed_base_helper{};
> template <int Bits>
> struct exact_unsigned_base_helper{};
>
> template <> struct exact_signed_base_helper<sizeof(signed char)* 8> { typedef signed char exact; };
> template <> struct exact_unsigned_base_helper<sizeof(unsigned char)* 8> { typedef unsigned char exact; };
>
> template <> struct exact_signed_base_helper<sizeof(short)* 8> { typedef short exact; };
> template <> struct exact_unsigned_base_helper<sizeof(unsigned short)* 8> { typedef unsigned short exact; };
>
>
> template <> struct exact_signed_base_helper<sizeof(int)* 8> { typedef int exact; };
> template <> struct exact_unsigned_base_helper<sizeof(unsigned int)* 8> { typedef unsigned int exact; };
>
>
> template <> struct exact_signed_base_helper<sizeof(long)* 8> { typedef long exact; };
> template <> struct exact_unsigned_base_helper<sizeof(unsigned long)* 8> { typedef unsigned long exact; };
># 108 "/usr/include/boost/integer.hpp" 3
> }
>
>
>
>
> template< int Bits >
> struct int_t : public detail::exact_signed_base_helper<Bits>
> {
> static_assert(Bits <= (int)(sizeof(boost::intmax_t) * 8), "No suitable signed integer type with the requested number of bits is available.")
> ;
> typedef typename detail::int_least_helper
> <
>
> (Bits <= (int)(sizeof(boost::long_long_type) * 8)) +
>
>
>
> (Bits-1 <= ::std::numeric_limits<long>::digits) +
> (Bits-1 <= ::std::numeric_limits<int>::digits) +
> (Bits-1 <= ::std::numeric_limits<short>::digits) +
> (Bits-1 <= ::std::numeric_limits<signed char>::digits)
> >::least least;
> typedef typename int_fast_t<least>::type fast;
> };
>
>
> template< int Bits >
> struct uint_t : public detail::exact_unsigned_base_helper<Bits>
> {
> static_assert(Bits <= (int)(sizeof(boost::uintmax_t) * 8), "No suitable unsigned integer type with the requested number of bits is available.")
> ;
># 149 "/usr/include/boost/integer.hpp" 3
> typedef typename detail::uint_least_helper
> <
>
> (Bits <= (int)(sizeof(boost::long_long_type) * 8)) +
>
>
>
> (Bits <= ::std::numeric_limits<unsigned long>::digits) +
> (Bits <= ::std::numeric_limits<unsigned int>::digits) +
> (Bits <= ::std::numeric_limits<unsigned short>::digits) +
> (Bits <= ::std::numeric_limits<unsigned char>::digits)
> >::least least;
>
> typedef typename int_fast_t<least>::type fast;
>
> };
>
>
>
>
>
> template< boost::long_long_type MaxValue >
>
>
>
> struct int_max_value_t
> {
> typedef typename detail::int_least_helper
> <
>
> (MaxValue <= ::boost::integer_traits<boost::long_long_type>::const_max) +
>
>
>
> (MaxValue <= ::boost::integer_traits<long>::const_max) +
> (MaxValue <= ::boost::integer_traits<int>::const_max) +
> (MaxValue <= ::boost::integer_traits<short>::const_max) +
> (MaxValue <= ::boost::integer_traits<signed char>::const_max)
> >::least least;
> typedef typename int_fast_t<least>::type fast;
> };
>
>
> template< boost::long_long_type MinValue >
>
>
>
> struct int_min_value_t
> {
> typedef typename detail::int_least_helper
> <
>
> (MinValue >= ::boost::integer_traits<boost::long_long_type>::const_min) +
>
>
>
> (MinValue >= ::boost::integer_traits<long>::const_min) +
> (MinValue >= ::boost::integer_traits<int>::const_min) +
> (MinValue >= ::boost::integer_traits<short>::const_min) +
> (MinValue >= ::boost::integer_traits<signed char>::const_min)
> >::least least;
> typedef typename int_fast_t<least>::type fast;
> };
>
>
>
> template< boost::ulong_long_type MaxValue >
>
>
>
> struct uint_value_t
> {
># 242 "/usr/include/boost/integer.hpp" 3
> typedef typename detail::uint_least_helper
> <
>
> (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +
>
>
>
> (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
> (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
> (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
> (MaxValue <= ::boost::integer_traits<unsigned char>::const_max)
> >::least least;
>
> typedef typename int_fast_t<least>::type fast;
> };
>
>
>}
># 22 "/usr/include/boost/function/function_base.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/composite_traits.hpp" 1 3 4
># 28 "/usr/include/boost/function/function_base.hpp" 2 3 4
># 38 "/usr/include/boost/function/function_base.hpp" 3 4
># 1 "/usr/include/boost/function_equal.hpp" 1 3 4
># 13 "/usr/include/boost/function_equal.hpp" 3 4
>namespace boost {
>
>template<typename F, typename G>
> bool function_equal_impl(const F& f, const G& g, long)
> { return f == g; }
>
>
>
>
>template<typename F, typename G>
> bool function_equal(const F& f, const G& g)
> { return function_equal_impl(f, g, 0); }
>
>}
># 39 "/usr/include/boost/function/function_base.hpp" 2 3 4
># 1 "/usr/include/boost/function/function_fwd.hpp" 1 3 4
># 28 "/usr/include/boost/function/function_fwd.hpp" 3 4
>namespace boost {
> class bad_function_call;
>
>
>
> template<typename Signature> class function;
>
> template<typename Signature>
> inline void swap(function<Signature>& f1, function<Signature>& f2)
> {
> f1.swap(f2);
> }
>
>
>
> template<typename R> class function0;
> template<typename R, typename T1> class function1;
> template<typename R, typename T1, typename T2> class function2;
> template<typename R, typename T1, typename T2, typename T3> class function3;
> template<typename R, typename T1, typename T2, typename T3, typename T4>
> class function4;
> template<typename R, typename T1, typename T2, typename T3, typename T4,
> typename T5>
> class function5;
> template<typename R, typename T1, typename T2, typename T3, typename T4,
> typename T5, typename T6>
> class function6;
> template<typename R, typename T1, typename T2, typename T3, typename T4,
> typename T5, typename T6, typename T7>
> class function7;
> template<typename R, typename T1, typename T2, typename T3, typename T4,
> typename T5, typename T6, typename T7, typename T8>
> class function8;
> template<typename R, typename T1, typename T2, typename T3, typename T4,
> typename T5, typename T6, typename T7, typename T8, typename T9>
> class function9;
> template<typename R, typename T1, typename T2, typename T3, typename T4,
> typename T5, typename T6, typename T7, typename T8, typename T9,
> typename T10>
> class function10;
>}
># 40 "/usr/include/boost/function/function_base.hpp" 2 3 4
># 62 "/usr/include/boost/function/function_base.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstring" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstring" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 63 "/usr/include/boost/function/function_base.hpp" 2 3 4
># 89 "/usr/include/boost/function/function_base.hpp" 3 4
>namespace boost {
> namespace detail {
> namespace function {
> class X;
>
>
>
>
>
>
>
> union function_buffer
> {
>
> mutable void* obj_ptr;
>
>
> struct type_t {
>
> const detail::sp_typeinfo* type;
>
>
> bool const_qualified;
>
> bool volatile_qualified;
> } type;
>
>
> mutable void (*func_ptr)();
>
>
> struct bound_memfunc_ptr_t {
> void (X::*memfunc_ptr)(int);
> void* obj_ptr;
> } bound_memfunc_ptr;
>
>
>
> struct obj_ref_t {
> mutable void* obj_ptr;
> bool is_const_qualified;
> bool is_volatile_qualified;
> } obj_ref;
>
>
> mutable char data;
> };
>
>
>
>
>
>
>
> struct unusable
> {
> unusable() {}
> template<typename T> unusable(const T&) {}
> };
>
>
>
>
>
> template<typename T> struct function_return_type { typedef T type; };
>
> template<>
> struct function_return_type<void>
> {
> typedef unusable type;
> };
>
>
> enum functor_manager_operation_type {
> clone_functor_tag,
> move_functor_tag,
> destroy_functor_tag,
> check_functor_type_tag,
> get_functor_type_tag
> };
>
>
> struct function_ptr_tag {};
> struct function_obj_tag {};
> struct member_ptr_tag {};
> struct function_obj_ref_tag {};
>
> template<typename F>
> class get_function_tag
> {
> typedef typename mpl::if_c<(is_pointer<F>::value),
> function_ptr_tag,
> function_obj_tag>::type ptr_or_obj_tag;
>
> typedef typename mpl::if_c<(is_member_pointer<F>::value),
> member_ptr_tag,
> ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
>
> typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
> function_obj_ref_tag,
> ptr_or_obj_or_mem_tag>::type or_ref_tag;
>
> public:
> typedef or_ref_tag type;
> };
>
>
>
> template<typename F>
> struct reference_manager
> {
> static inline void
> manage(const function_buffer& in_buffer, function_buffer& out_buffer,
> functor_manager_operation_type op)
> {
> switch (op) {
> case clone_functor_tag:
> out_buffer.obj_ref = in_buffer.obj_ref;
> return;
>
> case move_functor_tag:
> out_buffer.obj_ref = in_buffer.obj_ref;
> in_buffer.obj_ref.obj_ptr = 0;
> return;
>
> case destroy_functor_tag:
> out_buffer.obj_ref.obj_ptr = 0;
> return;
>
> case check_functor_type_tag:
> {
> const detail::sp_typeinfo& check_type
> = *out_buffer.type.type;
>
>
>
> if ((std::strcmp((check_type).name(),(typeid(F)).name()) == 0)
> && (!in_buffer.obj_ref.is_const_qualified
> || out_buffer.type.const_qualified)
> && (!in_buffer.obj_ref.is_volatile_qualified
> || out_buffer.type.volatile_qualified))
> out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr;
> else
> out_buffer.obj_ptr = 0;
> }
> return;
>
> case get_functor_type_tag:
> out_buffer.type.type = &typeid(F);
> out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
> out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
> return;
> }
> }
> };
>
>
>
>
>
> template<typename F>
> struct function_allows_small_object_optimization
> {
> static const bool value = ((sizeof(F) <= sizeof(function_buffer) && (alignment_of<function_buffer>::value % alignment_of<F>::value == 0)))
>
>
>
> ;
> };
>
> template <typename F,typename A>
> struct functor_wrapper: public F, public A
> {
> functor_wrapper( F f, A a ):
> F(f),
> A(a)
> {
> }
>
> functor_wrapper(const functor_wrapper& f) :
> F(static_cast<const F&>(f)),
> A(static_cast<const A&>(f))
> {
> }
> };
>
>
>
>
>
> template<typename Functor>
> struct functor_manager_common
> {
> typedef Functor functor_type;
>
>
> static inline void
> manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
> functor_manager_operation_type op)
> {
> if (op == clone_functor_tag)
> out_buffer.func_ptr = in_buffer.func_ptr;
> else if (op == move_functor_tag) {
> out_buffer.func_ptr = in_buffer.func_ptr;
> in_buffer.func_ptr = 0;
> } else if (op == destroy_functor_tag)
> out_buffer.func_ptr = 0;
> else if (op == check_functor_type_tag) {
> const detail::sp_typeinfo& check_type
> = *out_buffer.type.type;
> if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
> out_buffer.obj_ptr = &in_buffer.func_ptr;
> else
> out_buffer.obj_ptr = 0;
> } else {
> out_buffer.type.type = &typeid(Functor);
> out_buffer.type.const_qualified = false;
> out_buffer.type.volatile_qualified = false;
> }
> }
>
>
> static inline void
> manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
> functor_manager_operation_type op)
> {
> if (op == clone_functor_tag || op == move_functor_tag) {
> const functor_type* in_functor =
> reinterpret_cast<const functor_type*>(&in_buffer.data);
> new (reinterpret_cast<void*>(&out_buffer.data)) functor_type(*in_functor);
>
> if (op == move_functor_tag) {
> functor_type* f = reinterpret_cast<functor_type*>(&in_buffer.data);
> (void)f;
> f->~Functor();
> }
> } else if (op == destroy_functor_tag) {
>
> functor_type* f = reinterpret_cast<functor_type*>(&out_buffer.data);
> (void)f;
> f->~Functor();
> } else if (op == check_functor_type_tag) {
> const detail::sp_typeinfo& check_type
> = *out_buffer.type.type;
> if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
> out_buffer.obj_ptr = &in_buffer.data;
> else
> out_buffer.obj_ptr = 0;
> } else {
> out_buffer.type.type = &typeid(Functor);
> out_buffer.type.const_qualified = false;
> out_buffer.type.volatile_qualified = false;
> }
> }
> };
>
> template<typename Functor>
> struct functor_manager
> {
> private:
> typedef Functor functor_type;
>
>
> static inline void
> manager(const function_buffer& in_buffer, function_buffer& out_buffer,
> functor_manager_operation_type op, function_ptr_tag)
> {
> functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
> }
>
>
> static inline void
> manager(const function_buffer& in_buffer, function_buffer& out_buffer,
> functor_manager_operation_type op, mpl::true_)
> {
> functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
> }
>
>
> static inline void
> manager(const function_buffer& in_buffer, function_buffer& out_buffer,
> functor_manager_operation_type op, mpl::false_)
> {
> if (op == clone_functor_tag) {
>
>
>
>
>
> const functor_type* f =
> static_cast<const functor_type*>(in_buffer.obj_ptr);
> functor_type* new_f = new functor_type(*f);
> out_buffer.obj_ptr = new_f;
> } else if (op == move_functor_tag) {
> out_buffer.obj_ptr = in_buffer.obj_ptr;
> in_buffer.obj_ptr = 0;
> } else if (op == destroy_functor_tag) {
>
> functor_type* f =
> static_cast<functor_type*>(out_buffer.obj_ptr);
> delete f;
> out_buffer.obj_ptr = 0;
> } else if (op == check_functor_type_tag) {
> const detail::sp_typeinfo& check_type
> = *out_buffer.type.type;
> if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
> out_buffer.obj_ptr = in_buffer.obj_ptr;
> else
> out_buffer.obj_ptr = 0;
> } else {
> out_buffer.type.type = &typeid(Functor);
> out_buffer.type.const_qualified = false;
> out_buffer.type.volatile_qualified = false;
> }
> }
>
>
>
>
> static inline void
> manager(const function_buffer& in_buffer, function_buffer& out_buffer,
> functor_manager_operation_type op, function_obj_tag)
> {
> manager(in_buffer, out_buffer, op,
> mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
> }
>
>
> static inline void
> manager(const function_buffer& in_buffer, function_buffer& out_buffer,
> functor_manager_operation_type op, member_ptr_tag)
> {
> manager(in_buffer, out_buffer, op, mpl::true_());
> }
>
> public:
>
>
> static inline void
> manage(const function_buffer& in_buffer, function_buffer& out_buffer,
> functor_manager_operation_type op)
> {
> typedef typename get_function_tag<functor_type>::type tag_type;
> switch (op) {
> case get_functor_type_tag:
> out_buffer.type.type = &typeid(functor_type);
> out_buffer.type.const_qualified = false;
> out_buffer.type.volatile_qualified = false;
> return;
>
> default:
> manager(in_buffer, out_buffer, op, tag_type());
> return;
> }
> }
> };
>
> template<typename Functor, typename Allocator>
> struct functor_manager_a
> {
> private:
> typedef Functor functor_type;
>
>
> static inline void
> manager(const function_buffer& in_buffer, function_buffer& out_buffer,
> functor_manager_operation_type op, function_ptr_tag)
> {
> functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
> }
>
>
> static inline void
> manager(const function_buffer& in_buffer, function_buffer& out_buffer,
> functor_manager_operation_type op, mpl::true_)
> {
> functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
> }
>
>
> static inline void
> manager(const function_buffer& in_buffer, function_buffer& out_buffer,
> functor_manager_operation_type op, mpl::false_)
> {
> typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
> typedef typename Allocator::template rebind<functor_wrapper_type>::other
> wrapper_allocator_type;
> typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
>
> if (op == clone_functor_tag) {
>
>
>
> const functor_wrapper_type* f =
> static_cast<const functor_wrapper_type*>(in_buffer.obj_ptr);
> wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
> wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
> wrapper_allocator.construct(copy, *f);
>
>
> functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
> out_buffer.obj_ptr = new_f;
> } else if (op == move_functor_tag) {
> out_buffer.obj_ptr = in_buffer.obj_ptr;
> in_buffer.obj_ptr = 0;
> } else if (op == destroy_functor_tag) {
>
> functor_wrapper_type* victim =
> static_cast<functor_wrapper_type*>(in_buffer.obj_ptr);
> wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
> wrapper_allocator.destroy(victim);
> wrapper_allocator.deallocate(victim,1);
> out_buffer.obj_ptr = 0;
> } else if (op == check_functor_type_tag) {
> const detail::sp_typeinfo& check_type
> = *out_buffer.type.type;
> if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
> out_buffer.obj_ptr = in_buffer.obj_ptr;
> else
> out_buffer.obj_ptr = 0;
> } else {
> out_buffer.type.type = &typeid(Functor);
> out_buffer.type.const_qualified = false;
> out_buffer.type.volatile_qualified = false;
> }
> }
>
>
>
>
> static inline void
> manager(const function_buffer& in_buffer, function_buffer& out_buffer,
> functor_manager_operation_type op, function_obj_tag)
> {
> manager(in_buffer, out_buffer, op,
> mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
> }
>
> public:
>
>
> static inline void
> manage(const function_buffer& in_buffer, function_buffer& out_buffer,
> functor_manager_operation_type op)
> {
> typedef typename get_function_tag<functor_type>::type tag_type;
> switch (op) {
> case get_functor_type_tag:
> out_buffer.type.type = &typeid(functor_type);
> out_buffer.type.const_qualified = false;
> out_buffer.type.volatile_qualified = false;
> return;
>
> default:
> manager(in_buffer, out_buffer, op, tag_type());
> return;
> }
> }
> };
>
>
> struct useless_clear_type {};
># 615 "/usr/include/boost/function/function_base.hpp" 3 4
> struct vtable_base
> {
> void (*manager)(const function_buffer& in_buffer,
> function_buffer& out_buffer,
> functor_manager_operation_type op);
> };
> }
> }
>
>
>
>
>
>
>
>class function_base
>{
>public:
> function_base() : vtable(0) { }
>
>
> bool empty() const { return !vtable; }
>
>
>
> const detail::sp_typeinfo& target_type() const
> {
> if (!vtable) return typeid(void);
>
> detail::function::function_buffer type;
> get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
> return *type.type.type;
> }
>
> template<typename Functor>
> Functor* target()
> {
> if (!vtable) return 0;
>
> detail::function::function_buffer type_result;
> type_result.type.type = &typeid(Functor);
> type_result.type.const_qualified = is_const<Functor>::value;
> type_result.type.volatile_qualified = is_volatile<Functor>::value;
> get_vtable()->manager(functor, type_result,
> detail::function::check_functor_type_tag);
> return static_cast<Functor*>(type_result.obj_ptr);
> }
>
> template<typename Functor>
>
>
>
> const Functor* target() const
>
> {
> if (!vtable) return 0;
>
> detail::function::function_buffer type_result;
> type_result.type.type = &typeid(Functor);
> type_result.type.const_qualified = true;
> type_result.type.volatile_qualified = is_volatile<Functor>::value;
> get_vtable()->manager(functor, type_result,
> detail::function::check_functor_type_tag);
>
>
> return static_cast<const Functor*>(type_result.obj_ptr);
> }
>
> template<typename F>
> bool contains(const F& f) const
> {
>
>
>
> if (const F* fp = this->template target<F>())
>
> {
> return function_equal(*fp, f);
> } else {
> return false;
> }
> }
># 721 "/usr/include/boost/function/function_base.hpp" 3 4
>public:
> detail::function::vtable_base* get_vtable() const {
> return reinterpret_cast<detail::function::vtable_base*>(
> reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
> }
>
> bool has_trivial_copy_and_destroy() const {
> return reinterpret_cast<std::size_t>(vtable) & 0x01;
> }
>
> detail::function::vtable_base* vtable;
> mutable detail::function::function_buffer functor;
>};
>
>
>
>
>
>class bad_function_call : public std::runtime_error
>{
>public:
> bad_function_call() : std::runtime_error("call to empty boost::function") {}
>};
>
>
>inline bool operator==(const function_base& f,
> detail::function::useless_clear_type*)
>{
> return f.empty();
>}
>
>inline bool operator!=(const function_base& f,
> detail::function::useless_clear_type*)
>{
> return !f.empty();
>}
>
>inline bool operator==(detail::function::useless_clear_type*,
> const function_base& f)
>{
> return f.empty();
>}
>
>inline bool operator!=(detail::function::useless_clear_type*,
> const function_base& f)
>{
> return !f.empty();
>}
># 806 "/usr/include/boost/function/function_base.hpp" 3 4
>template<typename Functor>
> typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
> operator==(const function_base& f, Functor g)
> {
> if (const Functor* fp = f.template target<Functor>())
> return function_equal(*fp, g);
> else return false;
> }
>
>template<typename Functor>
> typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
> operator==(Functor g, const function_base& f)
> {
> if (const Functor* fp = f.template target<Functor>())
> return function_equal(g, *fp);
> else return false;
> }
>
>template<typename Functor>
> typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
> operator!=(const function_base& f, Functor g)
> {
> if (const Functor* fp = f.template target<Functor>())
> return !function_equal(*fp, g);
> else return true;
> }
>
>template<typename Functor>
> typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
> operator!=(Functor g, const function_base& f)
> {
> if (const Functor* fp = f.template target<Functor>())
> return !function_equal(g, *fp);
> else return true;
> }
>
>
>template<typename Functor>
> typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
> operator==(const function_base& f, reference_wrapper<Functor> g)
> {
> if (const Functor* fp = f.template target<Functor>())
> return fp == g.get_pointer();
> else return false;
> }
>
>template<typename Functor>
> typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
> operator==(reference_wrapper<Functor> g, const function_base& f)
> {
> if (const Functor* fp = f.template target<Functor>())
> return g.get_pointer() == fp;
> else return false;
> }
>
>template<typename Functor>
> typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
> operator!=(const function_base& f, reference_wrapper<Functor> g)
> {
> if (const Functor* fp = f.template target<Functor>())
> return fp != g.get_pointer();
> else return true;
> }
>
>template<typename Functor>
> typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
> operator!=(reference_wrapper<Functor> g, const function_base& f)
> {
> if (const Functor* fp = f.template target<Functor>())
> return g.get_pointer() != fp;
> else return true;
> }
>
>
>
>namespace detail {
> namespace function {
> inline bool has_empty_target(const function_base* f)
> {
> return f->empty();
> }
>
>
>
>
>
>
>
> inline bool has_empty_target(...)
> {
> return false;
> }
>
> }
>}
>}
># 18 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/preprocessor/enum.hpp" 1 3 4
># 21 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/enum_params.hpp" 1 3 4
># 22 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
># 25 "/usr/include/boost/function.hpp" 2 3 4
># 64 "/usr/include/boost/function.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
># 24 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
># 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
># 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
># 25 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
># 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
># 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
># 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
># 27 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
># 47 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
># 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
># 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
># 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
># 13 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
># 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
># 81 "/usr/include/boost/function/function_template.hpp" 3 4
>namespace boost {
> namespace detail {
> namespace function {
> template<
> typename FunctionPtr,
> typename R
> 
> >
> struct function_invoker0
> {
> static R invoke(function_buffer& function_ptr
> )
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> return f();
> }
> };
>
> template<
> typename FunctionPtr,
> typename R
> 
> >
> struct void_function_invoker0
> {
> static void
> invoke(function_buffer& function_ptr
> )
>
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> f();
> }
> };
>
> template<
> typename FunctionObj,
> typename R
> 
> >
> struct function_obj_invoker0
> {
> static R invoke(function_buffer& function_obj_ptr
> )
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)();
> }
> };
>
> template<
> typename FunctionObj,
> typename R
> 
> >
> struct void_function_obj_invoker0
> {
> static void
> invoke(function_buffer& function_obj_ptr
> )
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)();
> }
> };
>
> template<
> typename FunctionObj,
> typename R
> 
> >
> struct function_ref_invoker0
> {
> static R invoke(function_buffer& function_obj_ptr
> )
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)();
> }
> };
>
> template<
> typename FunctionObj,
> typename R
> 
> >
> struct void_function_ref_invoker0
> {
> static void
> invoke(function_buffer& function_obj_ptr
> )
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)();
> }
> };
># 230 "/usr/include/boost/function/function_template.hpp" 3 4
> template<
> typename FunctionPtr,
> typename R
> 
> >
> struct get_function_invoker0
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_invoker0<
> FunctionPtr,
> R
> 
> >,
> function_invoker0<
> FunctionPtr,
> R
> 
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R
> 
> >
> struct get_function_obj_invoker0
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_obj_invoker0<
> FunctionObj,
> R
> 
> >,
> function_obj_invoker0<
> FunctionObj,
> R
> 
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R
> 
> >
> struct get_function_ref_invoker0
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_ref_invoker0<
> FunctionObj,
> R
> 
> >,
> function_ref_invoker0<
> FunctionObj,
> R
> 
> >
> >::type type;
> };
># 326 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename Tag>
> struct get_invoker0 { };
>
>
> template<>
> struct get_invoker0<function_ptr_tag>
> {
> template<typename FunctionPtr,
> typename R >
> struct apply
> {
> typedef typename get_function_invoker0<
> FunctionPtr,
> R
> 
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
>
> template<typename FunctionPtr,
> typename R ,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_invoker0<
> FunctionPtr,
> R
> 
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
> };
># 400 "/usr/include/boost/function/function_template.hpp" 3 4
> template<>
> struct get_invoker0<function_obj_tag>
> {
> template<typename FunctionObj,
> typename R >
> struct apply
> {
> typedef typename get_function_obj_invoker0<
> FunctionObj,
> R
> 
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionObj> manager_type;
> };
>
> template<typename FunctionObj,
> typename R ,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_obj_invoker0<
> FunctionObj,
> R
> 
> >::type
> invoker_type;
>
> typedef functor_manager_a<FunctionObj, Allocator> manager_type;
> };
> };
>
>
> template<>
> struct get_invoker0<function_obj_ref_tag>
> {
> template<typename RefWrapper,
> typename R >
> struct apply
> {
> typedef typename get_function_ref_invoker0<
> typename RefWrapper::type,
> R
> 
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
>
> template<typename RefWrapper,
> typename R ,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_ref_invoker0<
> typename RefWrapper::type,
> R
> 
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
> };
># 475 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename R >
> struct basic_vtable0
> {
>
> typedef R result_type;
>
>
>
>
> typedef result_type (*invoker_type)(function_buffer&
> 
> );
>
> template<typename F>
> bool assign_to(F f, function_buffer& functor) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to(f, functor, tag());
> }
> template<typename F,typename Allocator>
> bool assign_to_a(F f, function_buffer& functor, Allocator a) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to_a(f, functor, a, tag());
> }
>
> void clear(function_buffer& functor) const
> {
> if (base.manager)
> base.manager(functor, functor, destroy_functor_tag);
> }
>
> private:
>
> template<typename FunctionPtr>
> bool
> assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
> {
> this->clear(functor);
> if (f) {
>
>
> functor.func_ptr = reinterpret_cast<void (*)()>(f);
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionPtr,typename Allocator>
> bool
> assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
> {
> return assign_to(f,functor,function_ptr_tag());
> }
># 562 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
> {
> new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
> {
> assign_functor(f,functor,mpl::true_());
> }
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
> {
> functor.obj_ptr = new FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
> {
> typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
> typedef typename Allocator::template rebind<functor_wrapper_type>::other
> wrapper_allocator_type;
> typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
> wrapper_allocator_type wrapper_allocator(a);
> wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
> wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
> functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
> functor.obj_ptr = new_f;
> }
>
> template<typename FunctionObj>
> bool
> assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor(f, functor,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor_a(f, functor, a,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
>
>
> template<typename FunctionObj>
> bool
> assign_to(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, function_obj_ref_tag) const
> {
> functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
> functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
> functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
> return true;
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, Allocator, function_obj_ref_tag) const
> {
> return assign_to(f,functor,function_obj_ref_tag());
> }
>
> public:
> vtable_base base;
> invoker_type invoker;
> };
> }
> }
>
> template<
> typename R
> 
> >
> class function0 : public function_base
># 664 "/usr/include/boost/function/function_template.hpp" 3 4
> {
> public:
>
> typedef R result_type;
>
>
>
>
>
> private:
> typedef boost::detail::function::basic_vtable0<
> R >
> vtable_type;
>
> vtable_type* get_vtable() const {
> return reinterpret_cast<vtable_type*>(
> reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
> }
>
> struct clear_type {};
>
> public:
> static const int args = 0;
>
>
> template<typename Args>
> struct sig
> {
> typedef result_type type;
> };
># 702 "/usr/include/boost/function/function_template.hpp" 3 4
> static const int arity = 0;
> 
>
> typedef function0 self_type;
>
> function0() : function_base() { }
>
>
>
> template<typename Functor>
> function0(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to(f);
> }
> template<typename Functor,typename Allocator>
> function0(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to_a(f,a);
> }
>
>
> function0(clear_type*) : function_base() { }
>
>
>
>
>
>
>
> function0(const function0& f) : function_base()
> {
> this->assign_to_own(f);
> }
>
>
> function0(function0&& f) : function_base()
> {
> this->move_assign(f);
> }
>
>
> ~function0() { clear(); }
>
> result_type operator()() const
> {
> if (this->empty())
> boost::throw_exception(bad_function_call());
>
> return get_vtable()->invoker
> (this->functor );
> }
>
>
>
>
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> function0&>::type
>
>
>
> operator=(Functor f)
> {
> this->clear();
> { try {
> this->assign_to(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
> template<typename Functor,typename Allocator>
> void assign(Functor f, Allocator a)
> {
> this->clear();
> { try{
> this->assign_to_a(f,a);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
>
>
> function0& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
># 825 "/usr/include/boost/function/function_template.hpp" 3 4
> function0& operator=(const function0& f)
> {
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->assign_to_own(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
>
> function0& operator=(function0&& f)
> {
>
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->move_assign(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
> void swap(function0& other)
> {
> if (&other == this)
> return;
>
> function0 tmp;
> tmp.move_assign(*this);
> this->move_assign(other);
> other.move_assign(tmp);
> }
>
>
> void clear()
> {
> if (vtable) {
> if (!this->has_trivial_copy_and_destroy())
> get_vtable()->clear(this->functor);
> vtable = 0;
> }
> }
>
>
>
>
>
> private:
> struct dummy {
> void nonnull() {}
> };
>
> typedef void (dummy::*safe_bool)();
>
> public:
> operator safe_bool () const
> { return (this->empty())? 0 : &dummy::nonnull; }
>
> bool operator!() const
> { return this->empty(); }
>
>
> private:
> void assign_to_own(const function0& f)
> {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::clone_functor_tag);
> }
> }
>
> template<typename Functor>
> void assign_to(Functor f)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker0<tag> get_invoker;
> typedef typename get_invoker::
> template apply<Functor, R
> >
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to(f, functor)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
> template<typename Functor,typename Allocator>
> void assign_to_a(Functor f,Allocator a)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker0<tag> get_invoker;
> typedef typename get_invoker::
> template apply_a<Functor, R
> ,
> Allocator>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to_a(f, functor, a)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<std::size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
>
>
>
> void move_assign(function0& f)
> {
> if (&f == this)
> return;
>
> { try {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::move_functor_tag);
> f.vtable = 0;
> } else {
> clear();
> }
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
> };
>
> template<typename R >
> inline void swap(function0<
> R
> 
> >& f1,
> function0<
> R
> 
> >& f2)
> {
> f1.swap(f2);
> }
>
>
>template<typename R >
> void operator==(const function0<
> R
> >&,
> const function0<
> R
> >&);
>template<typename R >
> void operator!=(const function0<
> R
> >&,
> const function0<
> R
> >& );
># 1046 "/usr/include/boost/function/function_template.hpp" 3 4
>template<typename R
> >
>class function<R (void)>
> : public function0<R >
>{
> typedef function0<R > base_type;
> typedef function self_type;
>
> struct clear_type {};
>
>public:
>
> function() : base_type() {}
>
> template<typename Functor>
> function(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f)
> {
> }
> template<typename Functor,typename Allocator>
> function(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f,a)
> {
> }
>
>
> function(clear_type*) : base_type() {}
>
>
> function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
>
> function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
>
>
>
> function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
> function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
>
>
> self_type& operator=(const self_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(self_type&& f)
> {
> self_type(static_cast<self_type&&>(f)).swap(*this);
> return *this;
> }
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> self_type&>::type
>
>
>
> operator=(Functor f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
>
>
> self_type& operator=(const base_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(base_type&& f)
> {
> self_type(static_cast<base_type&&>(f)).swap(*this);
> return *this;
> }
>
>};
>
>
>
>
>}
># 14 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
># 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
># 48 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
># 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
># 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
># 18 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
># 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
># 81 "/usr/include/boost/function/function_template.hpp" 3 4
>namespace boost {
> namespace detail {
> namespace function {
> template<
> typename FunctionPtr,
> typename R ,
> typename T0
> >
> struct function_invoker1
> {
> static R invoke(function_buffer& function_ptr ,
> T0 a0)
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> return f( a0);
> }
> };
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0
> >
> struct void_function_invoker1
> {
> static void
> invoke(function_buffer& function_ptr ,
> T0 a0)
>
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> f( a0);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0
> >
> struct function_obj_invoker1
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0
> >
> struct void_function_obj_invoker1
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0
> >
> struct function_ref_invoker1
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0
> >
> struct void_function_ref_invoker1
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0);
> }
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0
> >
> struct function_mem_invoker1
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> return boost::mem_fn(*f)( a0);
> }
> };
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0
> >
> struct function_void_mem_invoker1
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> boost::mem_fn(*f)( a0);
> }
> };
>
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0
> >
> struct get_function_invoker1
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_invoker1<
> FunctionPtr,
> R ,
> T0
> >,
> function_invoker1<
> FunctionPtr,
> R ,
> T0
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0
> >
> struct get_function_obj_invoker1
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_obj_invoker1<
> FunctionObj,
> R ,
> T0
> >,
> function_obj_invoker1<
> FunctionObj,
> R ,
> T0
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0
> >
> struct get_function_ref_invoker1
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_ref_invoker1<
> FunctionObj,
> R ,
> T0
> >,
> function_ref_invoker1<
> FunctionObj,
> R ,
> T0
> >
> >::type type;
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0
> >
> struct get_member_invoker1
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> function_void_mem_invoker1<
> MemberPtr,
> R ,
> T0
> >,
> function_mem_invoker1<
> MemberPtr,
> R ,
> T0
> >
> >::type type;
> };
># 326 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename Tag>
> struct get_invoker1 { };
>
>
> template<>
> struct get_invoker1<function_ptr_tag>
> {
> template<typename FunctionPtr,
> typename R , typename T0>
> struct apply
> {
> typedef typename get_function_invoker1<
> FunctionPtr,
> R ,
> T0
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
>
> template<typename FunctionPtr,
> typename R , typename T0,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_invoker1<
> FunctionPtr,
> R ,
> T0
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker1<member_ptr_tag>
> {
> template<typename MemberPtr,
> typename R , typename T0>
> struct apply
> {
> typedef typename get_member_invoker1<
> MemberPtr,
> R ,
> T0
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
>
> template<typename MemberPtr,
> typename R , typename T0,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_member_invoker1<
> MemberPtr,
> R ,
> T0
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker1<function_obj_tag>
> {
> template<typename FunctionObj,
> typename R , typename T0>
> struct apply
> {
> typedef typename get_function_obj_invoker1<
> FunctionObj,
> R ,
> T0
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionObj> manager_type;
> };
>
> template<typename FunctionObj,
> typename R , typename T0,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_obj_invoker1<
> FunctionObj,
> R ,
> T0
> >::type
> invoker_type;
>
> typedef functor_manager_a<FunctionObj, Allocator> manager_type;
> };
> };
>
>
> template<>
> struct get_invoker1<function_obj_ref_tag>
> {
> template<typename RefWrapper,
> typename R , typename T0>
> struct apply
> {
> typedef typename get_function_ref_invoker1<
> typename RefWrapper::type,
> R ,
> T0
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
>
> template<typename RefWrapper,
> typename R , typename T0,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_ref_invoker1<
> typename RefWrapper::type,
> R ,
> T0
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
> };
># 475 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename R , typename T0>
> struct basic_vtable1
> {
>
> typedef R result_type;
>
>
>
>
> typedef result_type (*invoker_type)(function_buffer&
> ,
> T0);
>
> template<typename F>
> bool assign_to(F f, function_buffer& functor) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to(f, functor, tag());
> }
> template<typename F,typename Allocator>
> bool assign_to_a(F f, function_buffer& functor, Allocator a) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to_a(f, functor, a, tag());
> }
>
> void clear(function_buffer& functor) const
> {
> if (base.manager)
> base.manager(functor, functor, destroy_functor_tag);
> }
>
> private:
>
> template<typename FunctionPtr>
> bool
> assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
> {
> this->clear(functor);
> if (f) {
>
>
> functor.func_ptr = reinterpret_cast<void (*)()>(f);
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionPtr,typename Allocator>
> bool
> assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
> {
> return assign_to(f,functor,function_ptr_tag());
> }
>
>
>
> template<typename MemberPtr>
> bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to(boost::mem_fn(f), functor);
> return true;
> } else {
> return false;
> }
> }
> template<typename MemberPtr,typename Allocator>
> bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to_a(boost::mem_fn(f), functor, a);
> return true;
> } else {
> return false;
> }
> }
>
>
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
> {
> new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
> {
> assign_functor(f,functor,mpl::true_());
> }
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
> {
> functor.obj_ptr = new FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
> {
> typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
> typedef typename Allocator::template rebind<functor_wrapper_type>::other
> wrapper_allocator_type;
> typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
> wrapper_allocator_type wrapper_allocator(a);
> wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
> wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
> functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
> functor.obj_ptr = new_f;
> }
>
> template<typename FunctionObj>
> bool
> assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor(f, functor,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor_a(f, functor, a,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
>
>
> template<typename FunctionObj>
> bool
> assign_to(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, function_obj_ref_tag) const
> {
> functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
> functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
> functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
> return true;
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, Allocator, function_obj_ref_tag) const
> {
> return assign_to(f,functor,function_obj_ref_tag());
> }
>
> public:
> vtable_base base;
> invoker_type invoker;
> };
> }
> }
>
> template<
> typename R ,
> typename T0
> >
> class function1 : public function_base
>
>
>
> , public std::unary_function<T0,R>
>
>
>
>
>
>
>
> {
> public:
>
> typedef R result_type;
>
>
>
>
>
> private:
> typedef boost::detail::function::basic_vtable1<
> R , T0>
> vtable_type;
>
> vtable_type* get_vtable() const {
> return reinterpret_cast<vtable_type*>(
> reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
> }
>
> struct clear_type {};
>
> public:
> static const int args = 1;
>
>
> template<typename Args>
> struct sig
> {
> typedef result_type type;
> };
>
>
> typedef T0 argument_type;
>
>
>
>
>
> static const int arity = 1;
> typedef T0 arg1_type;
>
> typedef function1 self_type;
>
> function1() : function_base() { }
>
>
>
> template<typename Functor>
> function1(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to(f);
> }
> template<typename Functor,typename Allocator>
> function1(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to_a(f,a);
> }
>
>
> function1(clear_type*) : function_base() { }
>
>
>
>
>
>
>
> function1(const function1& f) : function_base()
> {
> this->assign_to_own(f);
> }
>
>
> function1(function1&& f) : function_base()
> {
> this->move_assign(f);
> }
>
>
> ~function1() { clear(); }
>
> result_type operator()( T0 a0) const
> {
> if (this->empty())
> boost::throw_exception(bad_function_call());
>
> return get_vtable()->invoker
> (this->functor , a0);
> }
>
>
>
>
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> function1&>::type
>
>
>
> operator=(Functor f)
> {
> this->clear();
> { try {
> this->assign_to(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
> template<typename Functor,typename Allocator>
> void assign(Functor f, Allocator a)
> {
> this->clear();
> { try{
> this->assign_to_a(f,a);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
>
>
> function1& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
># 825 "/usr/include/boost/function/function_template.hpp" 3 4
> function1& operator=(const function1& f)
> {
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->assign_to_own(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
>
> function1& operator=(function1&& f)
> {
>
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->move_assign(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
> void swap(function1& other)
> {
> if (&other == this)
> return;
>
> function1 tmp;
> tmp.move_assign(*this);
> this->move_assign(other);
> other.move_assign(tmp);
> }
>
>
> void clear()
> {
> if (vtable) {
> if (!this->has_trivial_copy_and_destroy())
> get_vtable()->clear(this->functor);
> vtable = 0;
> }
> }
>
>
>
>
>
> private:
> struct dummy {
> void nonnull() {}
> };
>
> typedef void (dummy::*safe_bool)();
>
> public:
> operator safe_bool () const
> { return (this->empty())? 0 : &dummy::nonnull; }
>
> bool operator!() const
> { return this->empty(); }
>
>
> private:
> void assign_to_own(const function1& f)
> {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::clone_functor_tag);
> }
> }
>
> template<typename Functor>
> void assign_to(Functor f)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker1<tag> get_invoker;
> typedef typename get_invoker::
> template apply<Functor, R ,
> T0>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to(f, functor)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
> template<typename Functor,typename Allocator>
> void assign_to_a(Functor f,Allocator a)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker1<tag> get_invoker;
> typedef typename get_invoker::
> template apply_a<Functor, R ,
> T0,
> Allocator>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to_a(f, functor, a)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<std::size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
>
>
>
> void move_assign(function1& f)
> {
> if (&f == this)
> return;
>
> { try {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::move_functor_tag);
> f.vtable = 0;
> } else {
> clear();
> }
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
> };
>
> template<typename R , typename T0>
> inline void swap(function1<
> R ,
> T0
> >& f1,
> function1<
> R ,
> T0
> >& f2)
> {
> f1.swap(f2);
> }
>
>
>template<typename R , typename T0>
> void operator==(const function1<
> R ,
> T0>&,
> const function1<
> R ,
> T0>&);
>template<typename R , typename T0>
> void operator!=(const function1<
> R ,
> T0>&,
> const function1<
> R ,
> T0>& );
># 1046 "/usr/include/boost/function/function_template.hpp" 3 4
>template<typename R ,
> typename T0>
>class function<R ( T0)>
> : public function1<R , T0>
>{
> typedef function1<R , T0> base_type;
> typedef function self_type;
>
> struct clear_type {};
>
>public:
>
> function() : base_type() {}
>
> template<typename Functor>
> function(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f)
> {
> }
> template<typename Functor,typename Allocator>
> function(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f,a)
> {
> }
>
>
> function(clear_type*) : base_type() {}
>
>
> function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
>
> function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
>
>
>
> function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
> function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
>
>
> self_type& operator=(const self_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(self_type&& f)
> {
> self_type(static_cast<self_type&&>(f)).swap(*this);
> return *this;
> }
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> self_type&>::type
>
>
>
> operator=(Functor f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
>
>
> self_type& operator=(const base_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(base_type&& f)
> {
> self_type(static_cast<base_type&&>(f)).swap(*this);
> return *this;
> }
>
>};
>
>
>
>
>}
># 19 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
># 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
># 53 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
># 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
># 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
># 23 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
># 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
># 81 "/usr/include/boost/function/function_template.hpp" 3 4
>namespace boost {
> namespace detail {
> namespace function {
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1
> >
> struct function_invoker2
> {
> static R invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1)
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> return f( a0 , a1);
> }
> };
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1
> >
> struct void_function_invoker2
> {
> static void
> invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1)
>
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> f( a0 , a1);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1
> >
> struct function_obj_invoker2
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1
> >
> struct void_function_obj_invoker2
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1
> >
> struct function_ref_invoker2
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1
> >
> struct void_function_ref_invoker2
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1);
> }
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1
> >
> struct function_mem_invoker2
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> return boost::mem_fn(*f)( a0 , a1);
> }
> };
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1
> >
> struct function_void_mem_invoker2
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> boost::mem_fn(*f)( a0 , a1);
> }
> };
>
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1
> >
> struct get_function_invoker2
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_invoker2<
> FunctionPtr,
> R ,
> T0 , T1
> >,
> function_invoker2<
> FunctionPtr,
> R ,
> T0 , T1
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1
> >
> struct get_function_obj_invoker2
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_obj_invoker2<
> FunctionObj,
> R ,
> T0 , T1
> >,
> function_obj_invoker2<
> FunctionObj,
> R ,
> T0 , T1
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1
> >
> struct get_function_ref_invoker2
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_ref_invoker2<
> FunctionObj,
> R ,
> T0 , T1
> >,
> function_ref_invoker2<
> FunctionObj,
> R ,
> T0 , T1
> >
> >::type type;
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1
> >
> struct get_member_invoker2
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> function_void_mem_invoker2<
> MemberPtr,
> R ,
> T0 , T1
> >,
> function_mem_invoker2<
> MemberPtr,
> R ,
> T0 , T1
> >
> >::type type;
> };
># 326 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename Tag>
> struct get_invoker2 { };
>
>
> template<>
> struct get_invoker2<function_ptr_tag>
> {
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1>
> struct apply
> {
> typedef typename get_function_invoker2<
> FunctionPtr,
> R ,
> T0 , T1
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
>
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_invoker2<
> FunctionPtr,
> R ,
> T0 , T1
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker2<member_ptr_tag>
> {
> template<typename MemberPtr,
> typename R , typename T0 , typename T1>
> struct apply
> {
> typedef typename get_member_invoker2<
> MemberPtr,
> R ,
> T0 , T1
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
>
> template<typename MemberPtr,
> typename R , typename T0 , typename T1,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_member_invoker2<
> MemberPtr,
> R ,
> T0 , T1
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker2<function_obj_tag>
> {
> template<typename FunctionObj,
> typename R , typename T0 , typename T1>
> struct apply
> {
> typedef typename get_function_obj_invoker2<
> FunctionObj,
> R ,
> T0 , T1
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionObj> manager_type;
> };
>
> template<typename FunctionObj,
> typename R , typename T0 , typename T1,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_obj_invoker2<
> FunctionObj,
> R ,
> T0 , T1
> >::type
> invoker_type;
>
> typedef functor_manager_a<FunctionObj, Allocator> manager_type;
> };
> };
>
>
> template<>
> struct get_invoker2<function_obj_ref_tag>
> {
> template<typename RefWrapper,
> typename R , typename T0 , typename T1>
> struct apply
> {
> typedef typename get_function_ref_invoker2<
> typename RefWrapper::type,
> R ,
> T0 , T1
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
>
> template<typename RefWrapper,
> typename R , typename T0 , typename T1,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_ref_invoker2<
> typename RefWrapper::type,
> R ,
> T0 , T1
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
> };
># 475 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename R , typename T0 , typename T1>
> struct basic_vtable2
> {
>
> typedef R result_type;
>
>
>
>
> typedef result_type (*invoker_type)(function_buffer&
> ,
> T0 , T1);
>
> template<typename F>
> bool assign_to(F f, function_buffer& functor) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to(f, functor, tag());
> }
> template<typename F,typename Allocator>
> bool assign_to_a(F f, function_buffer& functor, Allocator a) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to_a(f, functor, a, tag());
> }
>
> void clear(function_buffer& functor) const
> {
> if (base.manager)
> base.manager(functor, functor, destroy_functor_tag);
> }
>
> private:
>
> template<typename FunctionPtr>
> bool
> assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
> {
> this->clear(functor);
> if (f) {
>
>
> functor.func_ptr = reinterpret_cast<void (*)()>(f);
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionPtr,typename Allocator>
> bool
> assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
> {
> return assign_to(f,functor,function_ptr_tag());
> }
>
>
>
> template<typename MemberPtr>
> bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to(boost::mem_fn(f), functor);
> return true;
> } else {
> return false;
> }
> }
> template<typename MemberPtr,typename Allocator>
> bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to_a(boost::mem_fn(f), functor, a);
> return true;
> } else {
> return false;
> }
> }
>
>
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
> {
> new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
> {
> assign_functor(f,functor,mpl::true_());
> }
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
> {
> functor.obj_ptr = new FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
> {
> typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
> typedef typename Allocator::template rebind<functor_wrapper_type>::other
> wrapper_allocator_type;
> typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
> wrapper_allocator_type wrapper_allocator(a);
> wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
> wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
> functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
> functor.obj_ptr = new_f;
> }
>
> template<typename FunctionObj>
> bool
> assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor(f, functor,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor_a(f, functor, a,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
>
>
> template<typename FunctionObj>
> bool
> assign_to(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, function_obj_ref_tag) const
> {
> functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
> functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
> functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
> return true;
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, Allocator, function_obj_ref_tag) const
> {
> return assign_to(f,functor,function_obj_ref_tag());
> }
>
> public:
> vtable_base base;
> invoker_type invoker;
> };
> }
> }
>
> template<
> typename R ,
> typename T0 , typename T1
> >
> class function2 : public function_base
>
>
>
>
>
>
>
> , public std::binary_function<T0,T1,R>
>
>
>
> {
> public:
>
> typedef R result_type;
>
>
>
>
>
> private:
> typedef boost::detail::function::basic_vtable2<
> R , T0 , T1>
> vtable_type;
>
> vtable_type* get_vtable() const {
> return reinterpret_cast<vtable_type*>(
> reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
> }
>
> struct clear_type {};
>
> public:
> static const int args = 2;
>
>
> template<typename Args>
> struct sig
> {
> typedef result_type type;
> };
>
>
>
>
> typedef T0 first_argument_type;
> typedef T1 second_argument_type;
>
>
> static const int arity = 2;
> typedef T0 arg1_type; typedef T1 arg2_type;
>
> typedef function2 self_type;
>
> function2() : function_base() { }
>
>
>
> template<typename Functor>
> function2(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to(f);
> }
> template<typename Functor,typename Allocator>
> function2(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to_a(f,a);
> }
>
>
> function2(clear_type*) : function_base() { }
>
>
>
>
>
>
>
> function2(const function2& f) : function_base()
> {
> this->assign_to_own(f);
> }
>
>
> function2(function2&& f) : function_base()
> {
> this->move_assign(f);
> }
>
>
> ~function2() { clear(); }
>
> result_type operator()( T0 a0 , T1 a1) const
> {
> if (this->empty())
> boost::throw_exception(bad_function_call());
>
> return get_vtable()->invoker
> (this->functor , a0 , a1);
> }
>
>
>
>
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> function2&>::type
>
>
>
> operator=(Functor f)
> {
> this->clear();
> { try {
> this->assign_to(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
> template<typename Functor,typename Allocator>
> void assign(Functor f, Allocator a)
> {
> this->clear();
> { try{
> this->assign_to_a(f,a);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
>
>
> function2& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
># 825 "/usr/include/boost/function/function_template.hpp" 3 4
> function2& operator=(const function2& f)
> {
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->assign_to_own(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
>
> function2& operator=(function2&& f)
> {
>
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->move_assign(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
> void swap(function2& other)
> {
> if (&other == this)
> return;
>
> function2 tmp;
> tmp.move_assign(*this);
> this->move_assign(other);
> other.move_assign(tmp);
> }
>
>
> void clear()
> {
> if (vtable) {
> if (!this->has_trivial_copy_and_destroy())
> get_vtable()->clear(this->functor);
> vtable = 0;
> }
> }
>
>
>
>
>
> private:
> struct dummy {
> void nonnull() {}
> };
>
> typedef void (dummy::*safe_bool)();
>
> public:
> operator safe_bool () const
> { return (this->empty())? 0 : &dummy::nonnull; }
>
> bool operator!() const
> { return this->empty(); }
>
>
> private:
> void assign_to_own(const function2& f)
> {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::clone_functor_tag);
> }
> }
>
> template<typename Functor>
> void assign_to(Functor f)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker2<tag> get_invoker;
> typedef typename get_invoker::
> template apply<Functor, R ,
> T0 , T1>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to(f, functor)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
> template<typename Functor,typename Allocator>
> void assign_to_a(Functor f,Allocator a)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker2<tag> get_invoker;
> typedef typename get_invoker::
> template apply_a<Functor, R ,
> T0 , T1,
> Allocator>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to_a(f, functor, a)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<std::size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
>
>
>
> void move_assign(function2& f)
> {
> if (&f == this)
> return;
>
> { try {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::move_functor_tag);
> f.vtable = 0;
> } else {
> clear();
> }
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
> };
>
> template<typename R , typename T0 , typename T1>
> inline void swap(function2<
> R ,
> T0 , T1
> >& f1,
> function2<
> R ,
> T0 , T1
> >& f2)
> {
> f1.swap(f2);
> }
>
>
>template<typename R , typename T0 , typename T1>
> void operator==(const function2<
> R ,
> T0 , T1>&,
> const function2<
> R ,
> T0 , T1>&);
>template<typename R , typename T0 , typename T1>
> void operator!=(const function2<
> R ,
> T0 , T1>&,
> const function2<
> R ,
> T0 , T1>& );
># 1046 "/usr/include/boost/function/function_template.hpp" 3 4
>template<typename R ,
> typename T0 , typename T1>
>class function<R ( T0 , T1)>
> : public function2<R , T0 , T1>
>{
> typedef function2<R , T0 , T1> base_type;
> typedef function self_type;
>
> struct clear_type {};
>
>public:
>
> function() : base_type() {}
>
> template<typename Functor>
> function(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f)
> {
> }
> template<typename Functor,typename Allocator>
> function(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f,a)
> {
> }
>
>
> function(clear_type*) : base_type() {}
>
>
> function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
>
> function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
>
>
>
> function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
> function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
>
>
> self_type& operator=(const self_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(self_type&& f)
> {
> self_type(static_cast<self_type&&>(f)).swap(*this);
> return *this;
> }
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> self_type&>::type
>
>
>
> operator=(Functor f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
>
>
> self_type& operator=(const base_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(base_type&& f)
> {
> self_type(static_cast<base_type&&>(f)).swap(*this);
> return *this;
> }
>
>};
>
>
>
>
>}
># 24 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
># 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
># 58 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
># 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
># 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
># 28 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
># 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
># 81 "/usr/include/boost/function/function_template.hpp" 3 4
>namespace boost {
> namespace detail {
> namespace function {
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2
> >
> struct function_invoker3
> {
> static R invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2)
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> return f( a0 , a1 , a2);
> }
> };
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2
> >
> struct void_function_invoker3
> {
> static void
> invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2)
>
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> f( a0 , a1 , a2);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2
> >
> struct function_obj_invoker3
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2
> >
> struct void_function_obj_invoker3
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2
> >
> struct function_ref_invoker3
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2
> >
> struct void_function_ref_invoker3
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2);
> }
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2
> >
> struct function_mem_invoker3
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> return boost::mem_fn(*f)( a0 , a1 , a2);
> }
> };
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2
> >
> struct function_void_mem_invoker3
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> boost::mem_fn(*f)( a0 , a1 , a2);
> }
> };
>
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2
> >
> struct get_function_invoker3
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_invoker3<
> FunctionPtr,
> R ,
> T0 , T1 , T2
> >,
> function_invoker3<
> FunctionPtr,
> R ,
> T0 , T1 , T2
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2
> >
> struct get_function_obj_invoker3
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_obj_invoker3<
> FunctionObj,
> R ,
> T0 , T1 , T2
> >,
> function_obj_invoker3<
> FunctionObj,
> R ,
> T0 , T1 , T2
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2
> >
> struct get_function_ref_invoker3
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_ref_invoker3<
> FunctionObj,
> R ,
> T0 , T1 , T2
> >,
> function_ref_invoker3<
> FunctionObj,
> R ,
> T0 , T1 , T2
> >
> >::type type;
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2
> >
> struct get_member_invoker3
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> function_void_mem_invoker3<
> MemberPtr,
> R ,
> T0 , T1 , T2
> >,
> function_mem_invoker3<
> MemberPtr,
> R ,
> T0 , T1 , T2
> >
> >::type type;
> };
># 326 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename Tag>
> struct get_invoker3 { };
>
>
> template<>
> struct get_invoker3<function_ptr_tag>
> {
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2>
> struct apply
> {
> typedef typename get_function_invoker3<
> FunctionPtr,
> R ,
> T0 , T1 , T2
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
>
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_invoker3<
> FunctionPtr,
> R ,
> T0 , T1 , T2
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker3<member_ptr_tag>
> {
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2>
> struct apply
> {
> typedef typename get_member_invoker3<
> MemberPtr,
> R ,
> T0 , T1 , T2
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
>
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_member_invoker3<
> MemberPtr,
> R ,
> T0 , T1 , T2
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker3<function_obj_tag>
> {
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2>
> struct apply
> {
> typedef typename get_function_obj_invoker3<
> FunctionObj,
> R ,
> T0 , T1 , T2
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionObj> manager_type;
> };
>
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_obj_invoker3<
> FunctionObj,
> R ,
> T0 , T1 , T2
> >::type
> invoker_type;
>
> typedef functor_manager_a<FunctionObj, Allocator> manager_type;
> };
> };
>
>
> template<>
> struct get_invoker3<function_obj_ref_tag>
> {
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2>
> struct apply
> {
> typedef typename get_function_ref_invoker3<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
>
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_ref_invoker3<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
> };
># 475 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename R , typename T0 , typename T1 , typename T2>
> struct basic_vtable3
> {
>
> typedef R result_type;
>
>
>
>
> typedef result_type (*invoker_type)(function_buffer&
> ,
> T0 , T1 , T2);
>
> template<typename F>
> bool assign_to(F f, function_buffer& functor) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to(f, functor, tag());
> }
> template<typename F,typename Allocator>
> bool assign_to_a(F f, function_buffer& functor, Allocator a) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to_a(f, functor, a, tag());
> }
>
> void clear(function_buffer& functor) const
> {
> if (base.manager)
> base.manager(functor, functor, destroy_functor_tag);
> }
>
> private:
>
> template<typename FunctionPtr>
> bool
> assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
> {
> this->clear(functor);
> if (f) {
>
>
> functor.func_ptr = reinterpret_cast<void (*)()>(f);
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionPtr,typename Allocator>
> bool
> assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
> {
> return assign_to(f,functor,function_ptr_tag());
> }
>
>
>
> template<typename MemberPtr>
> bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to(boost::mem_fn(f), functor);
> return true;
> } else {
> return false;
> }
> }
> template<typename MemberPtr,typename Allocator>
> bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to_a(boost::mem_fn(f), functor, a);
> return true;
> } else {
> return false;
> }
> }
>
>
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
> {
> new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
> {
> assign_functor(f,functor,mpl::true_());
> }
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
> {
> functor.obj_ptr = new FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
> {
> typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
> typedef typename Allocator::template rebind<functor_wrapper_type>::other
> wrapper_allocator_type;
> typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
> wrapper_allocator_type wrapper_allocator(a);
> wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
> wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
> functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
> functor.obj_ptr = new_f;
> }
>
> template<typename FunctionObj>
> bool
> assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor(f, functor,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor_a(f, functor, a,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
>
>
> template<typename FunctionObj>
> bool
> assign_to(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, function_obj_ref_tag) const
> {
> functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
> functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
> functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
> return true;
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, Allocator, function_obj_ref_tag) const
> {
> return assign_to(f,functor,function_obj_ref_tag());
> }
>
> public:
> vtable_base base;
> invoker_type invoker;
> };
> }
> }
>
> template<
> typename R ,
> typename T0 , typename T1 , typename T2
> >
> class function3 : public function_base
># 664 "/usr/include/boost/function/function_template.hpp" 3 4
> {
> public:
>
> typedef R result_type;
>
>
>
>
>
> private:
> typedef boost::detail::function::basic_vtable3<
> R , T0 , T1 , T2>
> vtable_type;
>
> vtable_type* get_vtable() const {
> return reinterpret_cast<vtable_type*>(
> reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
> }
>
> struct clear_type {};
>
> public:
> static const int args = 3;
>
>
> template<typename Args>
> struct sig
> {
> typedef result_type type;
> };
># 702 "/usr/include/boost/function/function_template.hpp" 3 4
> static const int arity = 3;
> typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type;
>
> typedef function3 self_type;
>
> function3() : function_base() { }
>
>
>
> template<typename Functor>
> function3(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to(f);
> }
> template<typename Functor,typename Allocator>
> function3(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to_a(f,a);
> }
>
>
> function3(clear_type*) : function_base() { }
>
>
>
>
>
>
>
> function3(const function3& f) : function_base()
> {
> this->assign_to_own(f);
> }
>
>
> function3(function3&& f) : function_base()
> {
> this->move_assign(f);
> }
>
>
> ~function3() { clear(); }
>
> result_type operator()( T0 a0 , T1 a1 , T2 a2) const
> {
> if (this->empty())
> boost::throw_exception(bad_function_call());
>
> return get_vtable()->invoker
> (this->functor , a0 , a1 , a2);
> }
>
>
>
>
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> function3&>::type
>
>
>
> operator=(Functor f)
> {
> this->clear();
> { try {
> this->assign_to(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
> template<typename Functor,typename Allocator>
> void assign(Functor f, Allocator a)
> {
> this->clear();
> { try{
> this->assign_to_a(f,a);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
>
>
> function3& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
># 825 "/usr/include/boost/function/function_template.hpp" 3 4
> function3& operator=(const function3& f)
> {
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->assign_to_own(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
>
> function3& operator=(function3&& f)
> {
>
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->move_assign(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
> void swap(function3& other)
> {
> if (&other == this)
> return;
>
> function3 tmp;
> tmp.move_assign(*this);
> this->move_assign(other);
> other.move_assign(tmp);
> }
>
>
> void clear()
> {
> if (vtable) {
> if (!this->has_trivial_copy_and_destroy())
> get_vtable()->clear(this->functor);
> vtable = 0;
> }
> }
>
>
>
>
>
> private:
> struct dummy {
> void nonnull() {}
> };
>
> typedef void (dummy::*safe_bool)();
>
> public:
> operator safe_bool () const
> { return (this->empty())? 0 : &dummy::nonnull; }
>
> bool operator!() const
> { return this->empty(); }
>
>
> private:
> void assign_to_own(const function3& f)
> {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::clone_functor_tag);
> }
> }
>
> template<typename Functor>
> void assign_to(Functor f)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker3<tag> get_invoker;
> typedef typename get_invoker::
> template apply<Functor, R ,
> T0 , T1 , T2>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to(f, functor)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
> template<typename Functor,typename Allocator>
> void assign_to_a(Functor f,Allocator a)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker3<tag> get_invoker;
> typedef typename get_invoker::
> template apply_a<Functor, R ,
> T0 , T1 , T2,
> Allocator>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to_a(f, functor, a)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<std::size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
>
>
>
> void move_assign(function3& f)
> {
> if (&f == this)
> return;
>
> { try {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::move_functor_tag);
> f.vtable = 0;
> } else {
> clear();
> }
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
> };
>
> template<typename R , typename T0 , typename T1 , typename T2>
> inline void swap(function3<
> R ,
> T0 , T1 , T2
> >& f1,
> function3<
> R ,
> T0 , T1 , T2
> >& f2)
> {
> f1.swap(f2);
> }
>
>
>template<typename R , typename T0 , typename T1 , typename T2>
> void operator==(const function3<
> R ,
> T0 , T1 , T2>&,
> const function3<
> R ,
> T0 , T1 , T2>&);
>template<typename R , typename T0 , typename T1 , typename T2>
> void operator!=(const function3<
> R ,
> T0 , T1 , T2>&,
> const function3<
> R ,
> T0 , T1 , T2>& );
># 1046 "/usr/include/boost/function/function_template.hpp" 3 4
>template<typename R ,
> typename T0 , typename T1 , typename T2>
>class function<R ( T0 , T1 , T2)>
> : public function3<R , T0 , T1 , T2>
>{
> typedef function3<R , T0 , T1 , T2> base_type;
> typedef function self_type;
>
> struct clear_type {};
>
>public:
>
> function() : base_type() {}
>
> template<typename Functor>
> function(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f)
> {
> }
> template<typename Functor,typename Allocator>
> function(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f,a)
> {
> }
>
>
> function(clear_type*) : base_type() {}
>
>
> function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
>
> function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
>
>
>
> function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
> function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
>
>
> self_type& operator=(const self_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(self_type&& f)
> {
> self_type(static_cast<self_type&&>(f)).swap(*this);
> return *this;
> }
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> self_type&>::type
>
>
>
> operator=(Functor f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
>
>
> self_type& operator=(const base_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(base_type&& f)
> {
> self_type(static_cast<base_type&&>(f)).swap(*this);
> return *this;
> }
>
>};
>
>
>
>
>}
># 29 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
># 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
># 63 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
># 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
># 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
># 33 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
># 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
># 81 "/usr/include/boost/function/function_template.hpp" 3 4
>namespace boost {
> namespace detail {
> namespace function {
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3
> >
> struct function_invoker4
> {
> static R invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3)
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> return f( a0 , a1 , a2 , a3);
> }
> };
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3
> >
> struct void_function_invoker4
> {
> static void
> invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3)
>
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> f( a0 , a1 , a2 , a3);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3
> >
> struct function_obj_invoker4
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2 , a3);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3
> >
> struct void_function_obj_invoker4
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2 , a3);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3
> >
> struct function_ref_invoker4
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2 , a3);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3
> >
> struct void_function_ref_invoker4
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2 , a3);
> }
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3
> >
> struct function_mem_invoker4
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> return boost::mem_fn(*f)( a0 , a1 , a2 , a3);
> }
> };
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3
> >
> struct function_void_mem_invoker4
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> boost::mem_fn(*f)( a0 , a1 , a2 , a3);
> }
> };
>
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3
> >
> struct get_function_invoker4
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_invoker4<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3
> >,
> function_invoker4<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3
> >
> struct get_function_obj_invoker4
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_obj_invoker4<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3
> >,
> function_obj_invoker4<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3
> >
> struct get_function_ref_invoker4
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_ref_invoker4<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3
> >,
> function_ref_invoker4<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3
> >
> >::type type;
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3
> >
> struct get_member_invoker4
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> function_void_mem_invoker4<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3
> >,
> function_mem_invoker4<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3
> >
> >::type type;
> };
># 326 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename Tag>
> struct get_invoker4 { };
>
>
> template<>
> struct get_invoker4<function_ptr_tag>
> {
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3>
> struct apply
> {
> typedef typename get_function_invoker4<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
>
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_invoker4<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker4<member_ptr_tag>
> {
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3>
> struct apply
> {
> typedef typename get_member_invoker4<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
>
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_member_invoker4<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker4<function_obj_tag>
> {
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2 , typename T3>
> struct apply
> {
> typedef typename get_function_obj_invoker4<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionObj> manager_type;
> };
>
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2 , typename T3,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_obj_invoker4<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3
> >::type
> invoker_type;
>
> typedef functor_manager_a<FunctionObj, Allocator> manager_type;
> };
> };
>
>
> template<>
> struct get_invoker4<function_obj_ref_tag>
> {
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2 , typename T3>
> struct apply
> {
> typedef typename get_function_ref_invoker4<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2 , T3
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
>
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2 , typename T3,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_ref_invoker4<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2 , T3
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
> };
># 475 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
> struct basic_vtable4
> {
>
> typedef R result_type;
>
>
>
>
> typedef result_type (*invoker_type)(function_buffer&
> ,
> T0 , T1 , T2 , T3);
>
> template<typename F>
> bool assign_to(F f, function_buffer& functor) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to(f, functor, tag());
> }
> template<typename F,typename Allocator>
> bool assign_to_a(F f, function_buffer& functor, Allocator a) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to_a(f, functor, a, tag());
> }
>
> void clear(function_buffer& functor) const
> {
> if (base.manager)
> base.manager(functor, functor, destroy_functor_tag);
> }
>
> private:
>
> template<typename FunctionPtr>
> bool
> assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
> {
> this->clear(functor);
> if (f) {
>
>
> functor.func_ptr = reinterpret_cast<void (*)()>(f);
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionPtr,typename Allocator>
> bool
> assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
> {
> return assign_to(f,functor,function_ptr_tag());
> }
>
>
>
> template<typename MemberPtr>
> bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to(boost::mem_fn(f), functor);
> return true;
> } else {
> return false;
> }
> }
> template<typename MemberPtr,typename Allocator>
> bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to_a(boost::mem_fn(f), functor, a);
> return true;
> } else {
> return false;
> }
> }
>
>
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
> {
> new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
> {
> assign_functor(f,functor,mpl::true_());
> }
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
> {
> functor.obj_ptr = new FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
> {
> typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
> typedef typename Allocator::template rebind<functor_wrapper_type>::other
> wrapper_allocator_type;
> typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
> wrapper_allocator_type wrapper_allocator(a);
> wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
> wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
> functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
> functor.obj_ptr = new_f;
> }
>
> template<typename FunctionObj>
> bool
> assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor(f, functor,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor_a(f, functor, a,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
>
>
> template<typename FunctionObj>
> bool
> assign_to(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, function_obj_ref_tag) const
> {
> functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
> functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
> functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
> return true;
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, Allocator, function_obj_ref_tag) const
> {
> return assign_to(f,functor,function_obj_ref_tag());
> }
>
> public:
> vtable_base base;
> invoker_type invoker;
> };
> }
> }
>
> template<
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3
> >
> class function4 : public function_base
># 664 "/usr/include/boost/function/function_template.hpp" 3 4
> {
> public:
>
> typedef R result_type;
>
>
>
>
>
> private:
> typedef boost::detail::function::basic_vtable4<
> R , T0 , T1 , T2 , T3>
> vtable_type;
>
> vtable_type* get_vtable() const {
> return reinterpret_cast<vtable_type*>(
> reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
> }
>
> struct clear_type {};
>
> public:
> static const int args = 4;
>
>
> template<typename Args>
> struct sig
> {
> typedef result_type type;
> };
># 702 "/usr/include/boost/function/function_template.hpp" 3 4
> static const int arity = 4;
> typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type;
>
> typedef function4 self_type;
>
> function4() : function_base() { }
>
>
>
> template<typename Functor>
> function4(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to(f);
> }
> template<typename Functor,typename Allocator>
> function4(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to_a(f,a);
> }
>
>
> function4(clear_type*) : function_base() { }
>
>
>
>
>
>
>
> function4(const function4& f) : function_base()
> {
> this->assign_to_own(f);
> }
>
>
> function4(function4&& f) : function_base()
> {
> this->move_assign(f);
> }
>
>
> ~function4() { clear(); }
>
> result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3) const
> {
> if (this->empty())
> boost::throw_exception(bad_function_call());
>
> return get_vtable()->invoker
> (this->functor , a0 , a1 , a2 , a3);
> }
>
>
>
>
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> function4&>::type
>
>
>
> operator=(Functor f)
> {
> this->clear();
> { try {
> this->assign_to(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
> template<typename Functor,typename Allocator>
> void assign(Functor f, Allocator a)
> {
> this->clear();
> { try{
> this->assign_to_a(f,a);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
>
>
> function4& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
># 825 "/usr/include/boost/function/function_template.hpp" 3 4
> function4& operator=(const function4& f)
> {
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->assign_to_own(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
>
> function4& operator=(function4&& f)
> {
>
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->move_assign(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
> void swap(function4& other)
> {
> if (&other == this)
> return;
>
> function4 tmp;
> tmp.move_assign(*this);
> this->move_assign(other);
> other.move_assign(tmp);
> }
>
>
> void clear()
> {
> if (vtable) {
> if (!this->has_trivial_copy_and_destroy())
> get_vtable()->clear(this->functor);
> vtable = 0;
> }
> }
>
>
>
>
>
> private:
> struct dummy {
> void nonnull() {}
> };
>
> typedef void (dummy::*safe_bool)();
>
> public:
> operator safe_bool () const
> { return (this->empty())? 0 : &dummy::nonnull; }
>
> bool operator!() const
> { return this->empty(); }
>
>
> private:
> void assign_to_own(const function4& f)
> {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::clone_functor_tag);
> }
> }
>
> template<typename Functor>
> void assign_to(Functor f)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker4<tag> get_invoker;
> typedef typename get_invoker::
> template apply<Functor, R ,
> T0 , T1 , T2 , T3>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to(f, functor)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
> template<typename Functor,typename Allocator>
> void assign_to_a(Functor f,Allocator a)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker4<tag> get_invoker;
> typedef typename get_invoker::
> template apply_a<Functor, R ,
> T0 , T1 , T2 , T3,
> Allocator>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to_a(f, functor, a)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<std::size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
>
>
>
> void move_assign(function4& f)
> {
> if (&f == this)
> return;
>
> { try {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::move_functor_tag);
> f.vtable = 0;
> } else {
> clear();
> }
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
> };
>
> template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
> inline void swap(function4<
> R ,
> T0 , T1 , T2 , T3
> >& f1,
> function4<
> R ,
> T0 , T1 , T2 , T3
> >& f2)
> {
> f1.swap(f2);
> }
>
>
>template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
> void operator==(const function4<
> R ,
> T0 , T1 , T2 , T3>&,
> const function4<
> R ,
> T0 , T1 , T2 , T3>&);
>template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
> void operator!=(const function4<
> R ,
> T0 , T1 , T2 , T3>&,
> const function4<
> R ,
> T0 , T1 , T2 , T3>& );
># 1046 "/usr/include/boost/function/function_template.hpp" 3 4
>template<typename R ,
> typename T0 , typename T1 , typename T2 , typename T3>
>class function<R ( T0 , T1 , T2 , T3)>
> : public function4<R , T0 , T1 , T2 , T3>
>{
> typedef function4<R , T0 , T1 , T2 , T3> base_type;
> typedef function self_type;
>
> struct clear_type {};
>
>public:
>
> function() : base_type() {}
>
> template<typename Functor>
> function(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f)
> {
> }
> template<typename Functor,typename Allocator>
> function(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f,a)
> {
> }
>
>
> function(clear_type*) : base_type() {}
>
>
> function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
>
> function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
>
>
>
> function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
> function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
>
>
> self_type& operator=(const self_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(self_type&& f)
> {
> self_type(static_cast<self_type&&>(f)).swap(*this);
> return *this;
> }
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> self_type&>::type
>
>
>
> operator=(Functor f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
>
>
> self_type& operator=(const base_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(base_type&& f)
> {
> self_type(static_cast<base_type&&>(f)).swap(*this);
> return *this;
> }
>
>};
>
>
>
>
>}
># 34 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
># 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
># 68 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
># 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
># 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
># 38 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
># 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
># 81 "/usr/include/boost/function/function_template.hpp" 3 4
>namespace boost {
> namespace detail {
> namespace function {
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4
> >
> struct function_invoker5
> {
> static R invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> return f( a0 , a1 , a2 , a3 , a4);
> }
> };
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4
> >
> struct void_function_invoker5
> {
> static void
> invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
>
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> f( a0 , a1 , a2 , a3 , a4);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4
> >
> struct function_obj_invoker5
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2 , a3 , a4);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4
> >
> struct void_function_obj_invoker5
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2 , a3 , a4);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4
> >
> struct function_ref_invoker5
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2 , a3 , a4);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4
> >
> struct void_function_ref_invoker5
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2 , a3 , a4);
> }
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4
> >
> struct function_mem_invoker5
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4);
> }
> };
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4
> >
> struct function_void_mem_invoker5
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4);
> }
> };
>
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4
> >
> struct get_function_invoker5
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_invoker5<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4
> >,
> function_invoker5<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4
> >
> struct get_function_obj_invoker5
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_obj_invoker5<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4
> >,
> function_obj_invoker5<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4
> >
> struct get_function_ref_invoker5
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_ref_invoker5<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4
> >,
> function_ref_invoker5<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4
> >
> >::type type;
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4
> >
> struct get_member_invoker5
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> function_void_mem_invoker5<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4
> >,
> function_mem_invoker5<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4
> >
> >::type type;
> };
># 326 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename Tag>
> struct get_invoker5 { };
>
>
> template<>
> struct get_invoker5<function_ptr_tag>
> {
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
> struct apply
> {
> typedef typename get_function_invoker5<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
>
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_invoker5<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker5<member_ptr_tag>
> {
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
> struct apply
> {
> typedef typename get_member_invoker5<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
>
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_member_invoker5<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker5<function_obj_tag>
> {
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
> struct apply
> {
> typedef typename get_function_obj_invoker5<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionObj> manager_type;
> };
>
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_obj_invoker5<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4
> >::type
> invoker_type;
>
> typedef functor_manager_a<FunctionObj, Allocator> manager_type;
> };
> };
>
>
> template<>
> struct get_invoker5<function_obj_ref_tag>
> {
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
> struct apply
> {
> typedef typename get_function_ref_invoker5<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2 , T3 , T4
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
>
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_ref_invoker5<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2 , T3 , T4
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
> };
># 475 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
> struct basic_vtable5
> {
>
> typedef R result_type;
>
>
>
>
> typedef result_type (*invoker_type)(function_buffer&
> ,
> T0 , T1 , T2 , T3 , T4);
>
> template<typename F>
> bool assign_to(F f, function_buffer& functor) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to(f, functor, tag());
> }
> template<typename F,typename Allocator>
> bool assign_to_a(F f, function_buffer& functor, Allocator a) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to_a(f, functor, a, tag());
> }
>
> void clear(function_buffer& functor) const
> {
> if (base.manager)
> base.manager(functor, functor, destroy_functor_tag);
> }
>
> private:
>
> template<typename FunctionPtr>
> bool
> assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
> {
> this->clear(functor);
> if (f) {
>
>
> functor.func_ptr = reinterpret_cast<void (*)()>(f);
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionPtr,typename Allocator>
> bool
> assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
> {
> return assign_to(f,functor,function_ptr_tag());
> }
>
>
>
> template<typename MemberPtr>
> bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to(boost::mem_fn(f), functor);
> return true;
> } else {
> return false;
> }
> }
> template<typename MemberPtr,typename Allocator>
> bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to_a(boost::mem_fn(f), functor, a);
> return true;
> } else {
> return false;
> }
> }
>
>
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
> {
> new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
> {
> assign_functor(f,functor,mpl::true_());
> }
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
> {
> functor.obj_ptr = new FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
> {
> typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
> typedef typename Allocator::template rebind<functor_wrapper_type>::other
> wrapper_allocator_type;
> typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
> wrapper_allocator_type wrapper_allocator(a);
> wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
> wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
> functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
> functor.obj_ptr = new_f;
> }
>
> template<typename FunctionObj>
> bool
> assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor(f, functor,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor_a(f, functor, a,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
>
>
> template<typename FunctionObj>
> bool
> assign_to(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, function_obj_ref_tag) const
> {
> functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
> functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
> functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
> return true;
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, Allocator, function_obj_ref_tag) const
> {
> return assign_to(f,functor,function_obj_ref_tag());
> }
>
> public:
> vtable_base base;
> invoker_type invoker;
> };
> }
> }
>
> template<
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4
> >
> class function5 : public function_base
># 664 "/usr/include/boost/function/function_template.hpp" 3 4
> {
> public:
>
> typedef R result_type;
>
>
>
>
>
> private:
> typedef boost::detail::function::basic_vtable5<
> R , T0 , T1 , T2 , T3 , T4>
> vtable_type;
>
> vtable_type* get_vtable() const {
> return reinterpret_cast<vtable_type*>(
> reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
> }
>
> struct clear_type {};
>
> public:
> static const int args = 5;
>
>
> template<typename Args>
> struct sig
> {
> typedef result_type type;
> };
># 702 "/usr/include/boost/function/function_template.hpp" 3 4
> static const int arity = 5;
> typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type;
>
> typedef function5 self_type;
>
> function5() : function_base() { }
>
>
>
> template<typename Functor>
> function5(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to(f);
> }
> template<typename Functor,typename Allocator>
> function5(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to_a(f,a);
> }
>
>
> function5(clear_type*) : function_base() { }
>
>
>
>
>
>
>
> function5(const function5& f) : function_base()
> {
> this->assign_to_own(f);
> }
>
>
> function5(function5&& f) : function_base()
> {
> this->move_assign(f);
> }
>
>
> ~function5() { clear(); }
>
> result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4) const
> {
> if (this->empty())
> boost::throw_exception(bad_function_call());
>
> return get_vtable()->invoker
> (this->functor , a0 , a1 , a2 , a3 , a4);
> }
>
>
>
>
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> function5&>::type
>
>
>
> operator=(Functor f)
> {
> this->clear();
> { try {
> this->assign_to(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
> template<typename Functor,typename Allocator>
> void assign(Functor f, Allocator a)
> {
> this->clear();
> { try{
> this->assign_to_a(f,a);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
>
>
> function5& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
># 825 "/usr/include/boost/function/function_template.hpp" 3 4
> function5& operator=(const function5& f)
> {
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->assign_to_own(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
>
> function5& operator=(function5&& f)
> {
>
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->move_assign(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
> void swap(function5& other)
> {
> if (&other == this)
> return;
>
> function5 tmp;
> tmp.move_assign(*this);
> this->move_assign(other);
> other.move_assign(tmp);
> }
>
>
> void clear()
> {
> if (vtable) {
> if (!this->has_trivial_copy_and_destroy())
> get_vtable()->clear(this->functor);
> vtable = 0;
> }
> }
>
>
>
>
>
> private:
> struct dummy {
> void nonnull() {}
> };
>
> typedef void (dummy::*safe_bool)();
>
> public:
> operator safe_bool () const
> { return (this->empty())? 0 : &dummy::nonnull; }
>
> bool operator!() const
> { return this->empty(); }
>
>
> private:
> void assign_to_own(const function5& f)
> {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::clone_functor_tag);
> }
> }
>
> template<typename Functor>
> void assign_to(Functor f)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker5<tag> get_invoker;
> typedef typename get_invoker::
> template apply<Functor, R ,
> T0 , T1 , T2 , T3 , T4>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to(f, functor)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
> template<typename Functor,typename Allocator>
> void assign_to_a(Functor f,Allocator a)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker5<tag> get_invoker;
> typedef typename get_invoker::
> template apply_a<Functor, R ,
> T0 , T1 , T2 , T3 , T4,
> Allocator>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to_a(f, functor, a)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<std::size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
>
>
>
> void move_assign(function5& f)
> {
> if (&f == this)
> return;
>
> { try {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::move_functor_tag);
> f.vtable = 0;
> } else {
> clear();
> }
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
> };
>
> template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
> inline void swap(function5<
> R ,
> T0 , T1 , T2 , T3 , T4
> >& f1,
> function5<
> R ,
> T0 , T1 , T2 , T3 , T4
> >& f2)
> {
> f1.swap(f2);
> }
>
>
>template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
> void operator==(const function5<
> R ,
> T0 , T1 , T2 , T3 , T4>&,
> const function5<
> R ,
> T0 , T1 , T2 , T3 , T4>&);
>template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
> void operator!=(const function5<
> R ,
> T0 , T1 , T2 , T3 , T4>&,
> const function5<
> R ,
> T0 , T1 , T2 , T3 , T4>& );
># 1046 "/usr/include/boost/function/function_template.hpp" 3 4
>template<typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
>class function<R ( T0 , T1 , T2 , T3 , T4)>
> : public function5<R , T0 , T1 , T2 , T3 , T4>
>{
> typedef function5<R , T0 , T1 , T2 , T3 , T4> base_type;
> typedef function self_type;
>
> struct clear_type {};
>
>public:
>
> function() : base_type() {}
>
> template<typename Functor>
> function(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f)
> {
> }
> template<typename Functor,typename Allocator>
> function(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f,a)
> {
> }
>
>
> function(clear_type*) : base_type() {}
>
>
> function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
>
> function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
>
>
>
> function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
> function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
>
>
> self_type& operator=(const self_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(self_type&& f)
> {
> self_type(static_cast<self_type&&>(f)).swap(*this);
> return *this;
> }
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> self_type&>::type
>
>
>
> operator=(Functor f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
>
>
> self_type& operator=(const base_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(base_type&& f)
> {
> self_type(static_cast<base_type&&>(f)).swap(*this);
> return *this;
> }
>
>};
>
>
>
>
>}
># 39 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
># 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
># 73 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
># 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
># 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
># 43 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
># 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
># 81 "/usr/include/boost/function/function_template.hpp" 3 4
>namespace boost {
> namespace detail {
> namespace function {
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
> >
> struct function_invoker6
> {
> static R invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> return f( a0 , a1 , a2 , a3 , a4 , a5);
> }
> };
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
> >
> struct void_function_invoker6
> {
> static void
> invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
>
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> f( a0 , a1 , a2 , a3 , a4 , a5);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
> >
> struct function_obj_invoker6
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2 , a3 , a4 , a5);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
> >
> struct void_function_obj_invoker6
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2 , a3 , a4 , a5);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
> >
> struct function_ref_invoker6
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2 , a3 , a4 , a5);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
> >
> struct void_function_ref_invoker6
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2 , a3 , a4 , a5);
> }
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
> >
> struct function_mem_invoker6
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5);
> }
> };
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
> >
> struct function_void_mem_invoker6
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5);
> }
> };
>
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
> >
> struct get_function_invoker6
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_invoker6<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >,
> function_invoker6<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
> >
> struct get_function_obj_invoker6
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_obj_invoker6<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >,
> function_obj_invoker6<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
> >
> struct get_function_ref_invoker6
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_ref_invoker6<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >,
> function_ref_invoker6<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >
> >::type type;
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
> >
> struct get_member_invoker6
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> function_void_mem_invoker6<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >,
> function_mem_invoker6<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >
> >::type type;
> };
># 326 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename Tag>
> struct get_invoker6 { };
>
>
> template<>
> struct get_invoker6<function_ptr_tag>
> {
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
> struct apply
> {
> typedef typename get_function_invoker6<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
>
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_invoker6<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker6<member_ptr_tag>
> {
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
> struct apply
> {
> typedef typename get_member_invoker6<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
>
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_member_invoker6<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker6<function_obj_tag>
> {
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
> struct apply
> {
> typedef typename get_function_obj_invoker6<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionObj> manager_type;
> };
>
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_obj_invoker6<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >::type
> invoker_type;
>
> typedef functor_manager_a<FunctionObj, Allocator> manager_type;
> };
> };
>
>
> template<>
> struct get_invoker6<function_obj_ref_tag>
> {
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
> struct apply
> {
> typedef typename get_function_ref_invoker6<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
>
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_ref_invoker6<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
> };
># 475 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
> struct basic_vtable6
> {
>
> typedef R result_type;
>
>
>
>
> typedef result_type (*invoker_type)(function_buffer&
> ,
> T0 , T1 , T2 , T3 , T4 , T5);
>
> template<typename F>
> bool assign_to(F f, function_buffer& functor) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to(f, functor, tag());
> }
> template<typename F,typename Allocator>
> bool assign_to_a(F f, function_buffer& functor, Allocator a) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to_a(f, functor, a, tag());
> }
>
> void clear(function_buffer& functor) const
> {
> if (base.manager)
> base.manager(functor, functor, destroy_functor_tag);
> }
>
> private:
>
> template<typename FunctionPtr>
> bool
> assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
> {
> this->clear(functor);
> if (f) {
>
>
> functor.func_ptr = reinterpret_cast<void (*)()>(f);
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionPtr,typename Allocator>
> bool
> assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
> {
> return assign_to(f,functor,function_ptr_tag());
> }
>
>
>
> template<typename MemberPtr>
> bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to(boost::mem_fn(f), functor);
> return true;
> } else {
> return false;
> }
> }
> template<typename MemberPtr,typename Allocator>
> bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to_a(boost::mem_fn(f), functor, a);
> return true;
> } else {
> return false;
> }
> }
>
>
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
> {
> new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
> {
> assign_functor(f,functor,mpl::true_());
> }
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
> {
> functor.obj_ptr = new FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
> {
> typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
> typedef typename Allocator::template rebind<functor_wrapper_type>::other
> wrapper_allocator_type;
> typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
> wrapper_allocator_type wrapper_allocator(a);
> wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
> wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
> functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
> functor.obj_ptr = new_f;
> }
>
> template<typename FunctionObj>
> bool
> assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor(f, functor,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor_a(f, functor, a,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
>
>
> template<typename FunctionObj>
> bool
> assign_to(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, function_obj_ref_tag) const
> {
> functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
> functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
> functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
> return true;
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, Allocator, function_obj_ref_tag) const
> {
> return assign_to(f,functor,function_obj_ref_tag());
> }
>
> public:
> vtable_base base;
> invoker_type invoker;
> };
> }
> }
>
> template<
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
> >
> class function6 : public function_base
># 664 "/usr/include/boost/function/function_template.hpp" 3 4
> {
> public:
>
> typedef R result_type;
>
>
>
>
>
> private:
> typedef boost::detail::function::basic_vtable6<
> R , T0 , T1 , T2 , T3 , T4 , T5>
> vtable_type;
>
> vtable_type* get_vtable() const {
> return reinterpret_cast<vtable_type*>(
> reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
> }
>
> struct clear_type {};
>
> public:
> static const int args = 6;
>
>
> template<typename Args>
> struct sig
> {
> typedef result_type type;
> };
># 702 "/usr/include/boost/function/function_template.hpp" 3 4
> static const int arity = 6;
> typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type;
>
> typedef function6 self_type;
>
> function6() : function_base() { }
>
>
>
> template<typename Functor>
> function6(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to(f);
> }
> template<typename Functor,typename Allocator>
> function6(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to_a(f,a);
> }
>
>
> function6(clear_type*) : function_base() { }
>
>
>
>
>
>
>
> function6(const function6& f) : function_base()
> {
> this->assign_to_own(f);
> }
>
>
> function6(function6&& f) : function_base()
> {
> this->move_assign(f);
> }
>
>
> ~function6() { clear(); }
>
> result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5) const
> {
> if (this->empty())
> boost::throw_exception(bad_function_call());
>
> return get_vtable()->invoker
> (this->functor , a0 , a1 , a2 , a3 , a4 , a5);
> }
>
>
>
>
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> function6&>::type
>
>
>
> operator=(Functor f)
> {
> this->clear();
> { try {
> this->assign_to(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
> template<typename Functor,typename Allocator>
> void assign(Functor f, Allocator a)
> {
> this->clear();
> { try{
> this->assign_to_a(f,a);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
>
>
> function6& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
># 825 "/usr/include/boost/function/function_template.hpp" 3 4
> function6& operator=(const function6& f)
> {
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->assign_to_own(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
>
> function6& operator=(function6&& f)
> {
>
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->move_assign(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
> void swap(function6& other)
> {
> if (&other == this)
> return;
>
> function6 tmp;
> tmp.move_assign(*this);
> this->move_assign(other);
> other.move_assign(tmp);
> }
>
>
> void clear()
> {
> if (vtable) {
> if (!this->has_trivial_copy_and_destroy())
> get_vtable()->clear(this->functor);
> vtable = 0;
> }
> }
>
>
>
>
>
> private:
> struct dummy {
> void nonnull() {}
> };
>
> typedef void (dummy::*safe_bool)();
>
> public:
> operator safe_bool () const
> { return (this->empty())? 0 : &dummy::nonnull; }
>
> bool operator!() const
> { return this->empty(); }
>
>
> private:
> void assign_to_own(const function6& f)
> {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::clone_functor_tag);
> }
> }
>
> template<typename Functor>
> void assign_to(Functor f)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker6<tag> get_invoker;
> typedef typename get_invoker::
> template apply<Functor, R ,
> T0 , T1 , T2 , T3 , T4 , T5>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to(f, functor)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
> template<typename Functor,typename Allocator>
> void assign_to_a(Functor f,Allocator a)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker6<tag> get_invoker;
> typedef typename get_invoker::
> template apply_a<Functor, R ,
> T0 , T1 , T2 , T3 , T4 , T5,
> Allocator>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to_a(f, functor, a)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<std::size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
>
>
>
> void move_assign(function6& f)
> {
> if (&f == this)
> return;
>
> { try {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::move_functor_tag);
> f.vtable = 0;
> } else {
> clear();
> }
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
> };
>
> template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
> inline void swap(function6<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >& f1,
> function6<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5
> >& f2)
> {
> f1.swap(f2);
> }
>
>
>template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
> void operator==(const function6<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5>&,
> const function6<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5>&);
>template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
> void operator!=(const function6<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5>&,
> const function6<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5>& );
># 1046 "/usr/include/boost/function/function_template.hpp" 3 4
>template<typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
>class function<R ( T0 , T1 , T2 , T3 , T4 , T5)>
> : public function6<R , T0 , T1 , T2 , T3 , T4 , T5>
>{
> typedef function6<R , T0 , T1 , T2 , T3 , T4 , T5> base_type;
> typedef function self_type;
>
> struct clear_type {};
>
>public:
>
> function() : base_type() {}
>
> template<typename Functor>
> function(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f)
> {
> }
> template<typename Functor,typename Allocator>
> function(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f,a)
> {
> }
>
>
> function(clear_type*) : base_type() {}
>
>
> function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
>
> function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
>
>
>
> function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
> function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
>
>
> self_type& operator=(const self_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(self_type&& f)
> {
> self_type(static_cast<self_type&&>(f)).swap(*this);
> return *this;
> }
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> self_type&>::type
>
>
>
> operator=(Functor f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
>
>
> self_type& operator=(const base_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(base_type&& f)
> {
> self_type(static_cast<base_type&&>(f)).swap(*this);
> return *this;
> }
>
>};
>
>
>
>
>}
># 44 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
># 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
># 78 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
># 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
># 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
># 48 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
># 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
># 81 "/usr/include/boost/function/function_template.hpp" 3 4
>namespace boost {
> namespace detail {
> namespace function {
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
> >
> struct function_invoker7
> {
> static R invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> return f( a0 , a1 , a2 , a3 , a4 , a5 , a6);
> }
> };
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
> >
> struct void_function_invoker7
> {
> static void
> invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
>
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> f( a0 , a1 , a2 , a3 , a4 , a5 , a6);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
> >
> struct function_obj_invoker7
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
> >
> struct void_function_obj_invoker7
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
> >
> struct function_ref_invoker7
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
> >
> struct void_function_ref_invoker7
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
> }
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
> >
> struct function_mem_invoker7
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
> }
> };
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
> >
> struct function_void_mem_invoker7
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
> }
> };
>
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
> >
> struct get_function_invoker7
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_invoker7<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >,
> function_invoker7<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
> >
> struct get_function_obj_invoker7
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_obj_invoker7<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >,
> function_obj_invoker7<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
> >
> struct get_function_ref_invoker7
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_ref_invoker7<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >,
> function_ref_invoker7<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >
> >::type type;
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
> >
> struct get_member_invoker7
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> function_void_mem_invoker7<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >,
> function_mem_invoker7<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >
> >::type type;
> };
># 326 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename Tag>
> struct get_invoker7 { };
>
>
> template<>
> struct get_invoker7<function_ptr_tag>
> {
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
> struct apply
> {
> typedef typename get_function_invoker7<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
>
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_invoker7<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker7<member_ptr_tag>
> {
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
> struct apply
> {
> typedef typename get_member_invoker7<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
>
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_member_invoker7<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker7<function_obj_tag>
> {
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
> struct apply
> {
> typedef typename get_function_obj_invoker7<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionObj> manager_type;
> };
>
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_obj_invoker7<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >::type
> invoker_type;
>
> typedef functor_manager_a<FunctionObj, Allocator> manager_type;
> };
> };
>
>
> template<>
> struct get_invoker7<function_obj_ref_tag>
> {
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
> struct apply
> {
> typedef typename get_function_ref_invoker7<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
>
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_ref_invoker7<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
> };
># 475 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
> struct basic_vtable7
> {
>
> typedef R result_type;
>
>
>
>
> typedef result_type (*invoker_type)(function_buffer&
> ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6);
>
> template<typename F>
> bool assign_to(F f, function_buffer& functor) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to(f, functor, tag());
> }
> template<typename F,typename Allocator>
> bool assign_to_a(F f, function_buffer& functor, Allocator a) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to_a(f, functor, a, tag());
> }
>
> void clear(function_buffer& functor) const
> {
> if (base.manager)
> base.manager(functor, functor, destroy_functor_tag);
> }
>
> private:
>
> template<typename FunctionPtr>
> bool
> assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
> {
> this->clear(functor);
> if (f) {
>
>
> functor.func_ptr = reinterpret_cast<void (*)()>(f);
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionPtr,typename Allocator>
> bool
> assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
> {
> return assign_to(f,functor,function_ptr_tag());
> }
>
>
>
> template<typename MemberPtr>
> bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to(boost::mem_fn(f), functor);
> return true;
> } else {
> return false;
> }
> }
> template<typename MemberPtr,typename Allocator>
> bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to_a(boost::mem_fn(f), functor, a);
> return true;
> } else {
> return false;
> }
> }
>
>
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
> {
> new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
> {
> assign_functor(f,functor,mpl::true_());
> }
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
> {
> functor.obj_ptr = new FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
> {
> typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
> typedef typename Allocator::template rebind<functor_wrapper_type>::other
> wrapper_allocator_type;
> typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
> wrapper_allocator_type wrapper_allocator(a);
> wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
> wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
> functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
> functor.obj_ptr = new_f;
> }
>
> template<typename FunctionObj>
> bool
> assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor(f, functor,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor_a(f, functor, a,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
>
>
> template<typename FunctionObj>
> bool
> assign_to(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, function_obj_ref_tag) const
> {
> functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
> functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
> functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
> return true;
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, Allocator, function_obj_ref_tag) const
> {
> return assign_to(f,functor,function_obj_ref_tag());
> }
>
> public:
> vtable_base base;
> invoker_type invoker;
> };
> }
> }
>
> template<
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
> >
> class function7 : public function_base
># 664 "/usr/include/boost/function/function_template.hpp" 3 4
> {
> public:
>
> typedef R result_type;
>
>
>
>
>
> private:
> typedef boost::detail::function::basic_vtable7<
> R , T0 , T1 , T2 , T3 , T4 , T5 , T6>
> vtable_type;
>
> vtable_type* get_vtable() const {
> return reinterpret_cast<vtable_type*>(
> reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
> }
>
> struct clear_type {};
>
> public:
> static const int args = 7;
>
>
> template<typename Args>
> struct sig
> {
> typedef result_type type;
> };
># 702 "/usr/include/boost/function/function_template.hpp" 3 4
> static const int arity = 7;
> typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type;
>
> typedef function7 self_type;
>
> function7() : function_base() { }
>
>
>
> template<typename Functor>
> function7(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to(f);
> }
> template<typename Functor,typename Allocator>
> function7(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to_a(f,a);
> }
>
>
> function7(clear_type*) : function_base() { }
>
>
>
>
>
>
>
> function7(const function7& f) : function_base()
> {
> this->assign_to_own(f);
> }
>
>
> function7(function7&& f) : function_base()
> {
> this->move_assign(f);
> }
>
>
> ~function7() { clear(); }
>
> result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6) const
> {
> if (this->empty())
> boost::throw_exception(bad_function_call());
>
> return get_vtable()->invoker
> (this->functor , a0 , a1 , a2 , a3 , a4 , a5 , a6);
> }
>
>
>
>
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> function7&>::type
>
>
>
> operator=(Functor f)
> {
> this->clear();
> { try {
> this->assign_to(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
> template<typename Functor,typename Allocator>
> void assign(Functor f, Allocator a)
> {
> this->clear();
> { try{
> this->assign_to_a(f,a);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
>
>
> function7& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
># 825 "/usr/include/boost/function/function_template.hpp" 3 4
> function7& operator=(const function7& f)
> {
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->assign_to_own(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
>
> function7& operator=(function7&& f)
> {
>
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->move_assign(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
> void swap(function7& other)
> {
> if (&other == this)
> return;
>
> function7 tmp;
> tmp.move_assign(*this);
> this->move_assign(other);
> other.move_assign(tmp);
> }
>
>
> void clear()
> {
> if (vtable) {
> if (!this->has_trivial_copy_and_destroy())
> get_vtable()->clear(this->functor);
> vtable = 0;
> }
> }
>
>
>
>
>
> private:
> struct dummy {
> void nonnull() {}
> };
>
> typedef void (dummy::*safe_bool)();
>
> public:
> operator safe_bool () const
> { return (this->empty())? 0 : &dummy::nonnull; }
>
> bool operator!() const
> { return this->empty(); }
>
>
> private:
> void assign_to_own(const function7& f)
> {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::clone_functor_tag);
> }
> }
>
> template<typename Functor>
> void assign_to(Functor f)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker7<tag> get_invoker;
> typedef typename get_invoker::
> template apply<Functor, R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to(f, functor)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
> template<typename Functor,typename Allocator>
> void assign_to_a(Functor f,Allocator a)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker7<tag> get_invoker;
> typedef typename get_invoker::
> template apply_a<Functor, R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6,
> Allocator>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to_a(f, functor, a)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<std::size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
>
>
>
> void move_assign(function7& f)
> {
> if (&f == this)
> return;
>
> { try {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::move_functor_tag);
> f.vtable = 0;
> } else {
> clear();
> }
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
> };
>
> template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
> inline void swap(function7<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >& f1,
> function7<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6
> >& f2)
> {
> f1.swap(f2);
> }
>
>
>template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
> void operator==(const function7<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6>&,
> const function7<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6>&);
>template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
> void operator!=(const function7<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6>&,
> const function7<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6>& );
># 1046 "/usr/include/boost/function/function_template.hpp" 3 4
>template<typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
>class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6)>
> : public function7<R , T0 , T1 , T2 , T3 , T4 , T5 , T6>
>{
> typedef function7<R , T0 , T1 , T2 , T3 , T4 , T5 , T6> base_type;
> typedef function self_type;
>
> struct clear_type {};
>
>public:
>
> function() : base_type() {}
>
> template<typename Functor>
> function(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f)
> {
> }
> template<typename Functor,typename Allocator>
> function(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f,a)
> {
> }
>
>
> function(clear_type*) : base_type() {}
>
>
> function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
>
> function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
>
>
>
> function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
> function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
>
>
> self_type& operator=(const self_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(self_type&& f)
> {
> self_type(static_cast<self_type&&>(f)).swap(*this);
> return *this;
> }
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> self_type&>::type
>
>
>
> operator=(Functor f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
>
>
> self_type& operator=(const base_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(base_type&& f)
> {
> self_type(static_cast<base_type&&>(f)).swap(*this);
> return *this;
> }
>
>};
>
>
>
>
>}
># 49 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
># 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
># 83 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
># 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
># 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
># 53 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
># 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
># 81 "/usr/include/boost/function/function_template.hpp" 3 4
>namespace boost {
> namespace detail {
> namespace function {
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
> >
> struct function_invoker8
> {
> static R invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> return f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
> }
> };
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
> >
> struct void_function_invoker8
> {
> static void
> invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
>
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
> >
> struct function_obj_invoker8
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
> >
> struct void_function_obj_invoker8
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
> >
> struct function_ref_invoker8
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
> >
> struct void_function_ref_invoker8
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
> }
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
> >
> struct function_mem_invoker8
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
> }
> };
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
> >
> struct function_void_mem_invoker8
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
> }
> };
>
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
> >
> struct get_function_invoker8
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_invoker8<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >,
> function_invoker8<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
> >
> struct get_function_obj_invoker8
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_obj_invoker8<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >,
> function_obj_invoker8<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
> >
> struct get_function_ref_invoker8
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_ref_invoker8<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >,
> function_ref_invoker8<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >
> >::type type;
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
> >
> struct get_member_invoker8
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> function_void_mem_invoker8<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >,
> function_mem_invoker8<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >
> >::type type;
> };
># 326 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename Tag>
> struct get_invoker8 { };
>
>
> template<>
> struct get_invoker8<function_ptr_tag>
> {
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
> struct apply
> {
> typedef typename get_function_invoker8<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
>
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_invoker8<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker8<member_ptr_tag>
> {
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
> struct apply
> {
> typedef typename get_member_invoker8<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
>
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_member_invoker8<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker8<function_obj_tag>
> {
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
> struct apply
> {
> typedef typename get_function_obj_invoker8<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionObj> manager_type;
> };
>
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_obj_invoker8<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >::type
> invoker_type;
>
> typedef functor_manager_a<FunctionObj, Allocator> manager_type;
> };
> };
>
>
> template<>
> struct get_invoker8<function_obj_ref_tag>
> {
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
> struct apply
> {
> typedef typename get_function_ref_invoker8<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
>
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_ref_invoker8<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
> };
># 475 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
> struct basic_vtable8
> {
>
> typedef R result_type;
>
>
>
>
> typedef result_type (*invoker_type)(function_buffer&
> ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7);
>
> template<typename F>
> bool assign_to(F f, function_buffer& functor) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to(f, functor, tag());
> }
> template<typename F,typename Allocator>
> bool assign_to_a(F f, function_buffer& functor, Allocator a) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to_a(f, functor, a, tag());
> }
>
> void clear(function_buffer& functor) const
> {
> if (base.manager)
> base.manager(functor, functor, destroy_functor_tag);
> }
>
> private:
>
> template<typename FunctionPtr>
> bool
> assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
> {
> this->clear(functor);
> if (f) {
>
>
> functor.func_ptr = reinterpret_cast<void (*)()>(f);
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionPtr,typename Allocator>
> bool
> assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
> {
> return assign_to(f,functor,function_ptr_tag());
> }
>
>
>
> template<typename MemberPtr>
> bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to(boost::mem_fn(f), functor);
> return true;
> } else {
> return false;
> }
> }
> template<typename MemberPtr,typename Allocator>
> bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to_a(boost::mem_fn(f), functor, a);
> return true;
> } else {
> return false;
> }
> }
>
>
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
> {
> new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
> {
> assign_functor(f,functor,mpl::true_());
> }
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
> {
> functor.obj_ptr = new FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
> {
> typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
> typedef typename Allocator::template rebind<functor_wrapper_type>::other
> wrapper_allocator_type;
> typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
> wrapper_allocator_type wrapper_allocator(a);
> wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
> wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
> functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
> functor.obj_ptr = new_f;
> }
>
> template<typename FunctionObj>
> bool
> assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor(f, functor,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor_a(f, functor, a,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
>
>
> template<typename FunctionObj>
> bool
> assign_to(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, function_obj_ref_tag) const
> {
> functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
> functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
> functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
> return true;
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, Allocator, function_obj_ref_tag) const
> {
> return assign_to(f,functor,function_obj_ref_tag());
> }
>
> public:
> vtable_base base;
> invoker_type invoker;
> };
> }
> }
>
> template<
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
> >
> class function8 : public function_base
># 664 "/usr/include/boost/function/function_template.hpp" 3 4
> {
> public:
>
> typedef R result_type;
>
>
>
>
>
> private:
> typedef boost::detail::function::basic_vtable8<
> R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
> vtable_type;
>
> vtable_type* get_vtable() const {
> return reinterpret_cast<vtable_type*>(
> reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
> }
>
> struct clear_type {};
>
> public:
> static const int args = 8;
>
>
> template<typename Args>
> struct sig
> {
> typedef result_type type;
> };
># 702 "/usr/include/boost/function/function_template.hpp" 3 4
> static const int arity = 8;
> typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type;
>
> typedef function8 self_type;
>
> function8() : function_base() { }
>
>
>
> template<typename Functor>
> function8(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to(f);
> }
> template<typename Functor,typename Allocator>
> function8(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to_a(f,a);
> }
>
>
> function8(clear_type*) : function_base() { }
>
>
>
>
>
>
>
> function8(const function8& f) : function_base()
> {
> this->assign_to_own(f);
> }
>
>
> function8(function8&& f) : function_base()
> {
> this->move_assign(f);
> }
>
>
> ~function8() { clear(); }
>
> result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7) const
> {
> if (this->empty())
> boost::throw_exception(bad_function_call());
>
> return get_vtable()->invoker
> (this->functor , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
> }
>
>
>
>
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> function8&>::type
>
>
>
> operator=(Functor f)
> {
> this->clear();
> { try {
> this->assign_to(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
> template<typename Functor,typename Allocator>
> void assign(Functor f, Allocator a)
> {
> this->clear();
> { try{
> this->assign_to_a(f,a);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
>
>
> function8& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
># 825 "/usr/include/boost/function/function_template.hpp" 3 4
> function8& operator=(const function8& f)
> {
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->assign_to_own(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
>
> function8& operator=(function8&& f)
> {
>
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->move_assign(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
> void swap(function8& other)
> {
> if (&other == this)
> return;
>
> function8 tmp;
> tmp.move_assign(*this);
> this->move_assign(other);
> other.move_assign(tmp);
> }
>
>
> void clear()
> {
> if (vtable) {
> if (!this->has_trivial_copy_and_destroy())
> get_vtable()->clear(this->functor);
> vtable = 0;
> }
> }
>
>
>
>
>
> private:
> struct dummy {
> void nonnull() {}
> };
>
> typedef void (dummy::*safe_bool)();
>
> public:
> operator safe_bool () const
> { return (this->empty())? 0 : &dummy::nonnull; }
>
> bool operator!() const
> { return this->empty(); }
>
>
> private:
> void assign_to_own(const function8& f)
> {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::clone_functor_tag);
> }
> }
>
> template<typename Functor>
> void assign_to(Functor f)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker8<tag> get_invoker;
> typedef typename get_invoker::
> template apply<Functor, R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to(f, functor)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
> template<typename Functor,typename Allocator>
> void assign_to_a(Functor f,Allocator a)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker8<tag> get_invoker;
> typedef typename get_invoker::
> template apply_a<Functor, R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7,
> Allocator>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to_a(f, functor, a)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<std::size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
>
>
>
> void move_assign(function8& f)
> {
> if (&f == this)
> return;
>
> { try {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::move_functor_tag);
> f.vtable = 0;
> } else {
> clear();
> }
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
> };
>
> template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
> inline void swap(function8<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >& f1,
> function8<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
> >& f2)
> {
> f1.swap(f2);
> }
>
>
>template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
> void operator==(const function8<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>&,
> const function8<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>&);
>template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
> void operator!=(const function8<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>&,
> const function8<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>& );
># 1046 "/usr/include/boost/function/function_template.hpp" 3 4
>template<typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
>class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)>
> : public function8<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
>{
> typedef function8<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> base_type;
> typedef function self_type;
>
> struct clear_type {};
>
>public:
>
> function() : base_type() {}
>
> template<typename Functor>
> function(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f)
> {
> }
> template<typename Functor,typename Allocator>
> function(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f,a)
> {
> }
>
>
> function(clear_type*) : base_type() {}
>
>
> function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
>
> function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
>
>
>
> function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
> function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
>
>
> self_type& operator=(const self_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(self_type&& f)
> {
> self_type(static_cast<self_type&&>(f)).swap(*this);
> return *this;
> }
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> self_type&>::type
>
>
>
> operator=(Functor f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
>
>
> self_type& operator=(const base_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(base_type&& f)
> {
> self_type(static_cast<base_type&&>(f)).swap(*this);
> return *this;
> }
>
>};
>
>
>
>
>}
># 54 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
># 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
># 88 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
># 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
># 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
># 58 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
># 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
># 81 "/usr/include/boost/function/function_template.hpp" 3 4
>namespace boost {
> namespace detail {
> namespace function {
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
> >
> struct function_invoker9
> {
> static R invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> return f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
> }
> };
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
> >
> struct void_function_invoker9
> {
> static void
> invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
>
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
> >
> struct function_obj_invoker9
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
> >
> struct void_function_obj_invoker9
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
> >
> struct function_ref_invoker9
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
> >
> struct void_function_ref_invoker9
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
> }
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
> >
> struct function_mem_invoker9
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
> }
> };
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
> >
> struct function_void_mem_invoker9
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
> }
> };
>
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
> >
> struct get_function_invoker9
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_invoker9<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >,
> function_invoker9<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
> >
> struct get_function_obj_invoker9
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_obj_invoker9<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >,
> function_obj_invoker9<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
> >
> struct get_function_ref_invoker9
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_ref_invoker9<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >,
> function_ref_invoker9<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >
> >::type type;
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
> >
> struct get_member_invoker9
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> function_void_mem_invoker9<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >,
> function_mem_invoker9<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >
> >::type type;
> };
># 326 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename Tag>
> struct get_invoker9 { };
>
>
> template<>
> struct get_invoker9<function_ptr_tag>
> {
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
> struct apply
> {
> typedef typename get_function_invoker9<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
>
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_invoker9<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker9<member_ptr_tag>
> {
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
> struct apply
> {
> typedef typename get_member_invoker9<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
>
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_member_invoker9<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker9<function_obj_tag>
> {
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
> struct apply
> {
> typedef typename get_function_obj_invoker9<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionObj> manager_type;
> };
>
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_obj_invoker9<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >::type
> invoker_type;
>
> typedef functor_manager_a<FunctionObj, Allocator> manager_type;
> };
> };
>
>
> template<>
> struct get_invoker9<function_obj_ref_tag>
> {
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
> struct apply
> {
> typedef typename get_function_ref_invoker9<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
>
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_ref_invoker9<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
> };
># 475 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
> struct basic_vtable9
> {
>
> typedef R result_type;
>
>
>
>
> typedef result_type (*invoker_type)(function_buffer&
> ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8);
>
> template<typename F>
> bool assign_to(F f, function_buffer& functor) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to(f, functor, tag());
> }
> template<typename F,typename Allocator>
> bool assign_to_a(F f, function_buffer& functor, Allocator a) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to_a(f, functor, a, tag());
> }
>
> void clear(function_buffer& functor) const
> {
> if (base.manager)
> base.manager(functor, functor, destroy_functor_tag);
> }
>
> private:
>
> template<typename FunctionPtr>
> bool
> assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
> {
> this->clear(functor);
> if (f) {
>
>
> functor.func_ptr = reinterpret_cast<void (*)()>(f);
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionPtr,typename Allocator>
> bool
> assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
> {
> return assign_to(f,functor,function_ptr_tag());
> }
>
>
>
> template<typename MemberPtr>
> bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to(boost::mem_fn(f), functor);
> return true;
> } else {
> return false;
> }
> }
> template<typename MemberPtr,typename Allocator>
> bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to_a(boost::mem_fn(f), functor, a);
> return true;
> } else {
> return false;
> }
> }
>
>
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
> {
> new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
> {
> assign_functor(f,functor,mpl::true_());
> }
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
> {
> functor.obj_ptr = new FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
> {
> typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
> typedef typename Allocator::template rebind<functor_wrapper_type>::other
> wrapper_allocator_type;
> typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
> wrapper_allocator_type wrapper_allocator(a);
> wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
> wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
> functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
> functor.obj_ptr = new_f;
> }
>
> template<typename FunctionObj>
> bool
> assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor(f, functor,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor_a(f, functor, a,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
>
>
> template<typename FunctionObj>
> bool
> assign_to(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, function_obj_ref_tag) const
> {
> functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
> functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
> functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
> return true;
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, Allocator, function_obj_ref_tag) const
> {
> return assign_to(f,functor,function_obj_ref_tag());
> }
>
> public:
> vtable_base base;
> invoker_type invoker;
> };
> }
> }
>
> template<
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
> >
> class function9 : public function_base
># 664 "/usr/include/boost/function/function_template.hpp" 3 4
> {
> public:
>
> typedef R result_type;
>
>
>
>
>
> private:
> typedef boost::detail::function::basic_vtable9<
> R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
> vtable_type;
>
> vtable_type* get_vtable() const {
> return reinterpret_cast<vtable_type*>(
> reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
> }
>
> struct clear_type {};
>
> public:
> static const int args = 9;
>
>
> template<typename Args>
> struct sig
> {
> typedef result_type type;
> };
># 702 "/usr/include/boost/function/function_template.hpp" 3 4
> static const int arity = 9;
> typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; typedef T8 arg9_type;
>
> typedef function9 self_type;
>
> function9() : function_base() { }
>
>
>
> template<typename Functor>
> function9(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to(f);
> }
> template<typename Functor,typename Allocator>
> function9(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to_a(f,a);
> }
>
>
> function9(clear_type*) : function_base() { }
>
>
>
>
>
>
>
> function9(const function9& f) : function_base()
> {
> this->assign_to_own(f);
> }
>
>
> function9(function9&& f) : function_base()
> {
> this->move_assign(f);
> }
>
>
> ~function9() { clear(); }
>
> result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8) const
> {
> if (this->empty())
> boost::throw_exception(bad_function_call());
>
> return get_vtable()->invoker
> (this->functor , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
> }
>
>
>
>
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> function9&>::type
>
>
>
> operator=(Functor f)
> {
> this->clear();
> { try {
> this->assign_to(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
> template<typename Functor,typename Allocator>
> void assign(Functor f, Allocator a)
> {
> this->clear();
> { try{
> this->assign_to_a(f,a);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
>
>
> function9& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
># 825 "/usr/include/boost/function/function_template.hpp" 3 4
> function9& operator=(const function9& f)
> {
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->assign_to_own(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
>
> function9& operator=(function9&& f)
> {
>
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->move_assign(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
> void swap(function9& other)
> {
> if (&other == this)
> return;
>
> function9 tmp;
> tmp.move_assign(*this);
> this->move_assign(other);
> other.move_assign(tmp);
> }
>
>
> void clear()
> {
> if (vtable) {
> if (!this->has_trivial_copy_and_destroy())
> get_vtable()->clear(this->functor);
> vtable = 0;
> }
> }
>
>
>
>
>
> private:
> struct dummy {
> void nonnull() {}
> };
>
> typedef void (dummy::*safe_bool)();
>
> public:
> operator safe_bool () const
> { return (this->empty())? 0 : &dummy::nonnull; }
>
> bool operator!() const
> { return this->empty(); }
>
>
> private:
> void assign_to_own(const function9& f)
> {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::clone_functor_tag);
> }
> }
>
> template<typename Functor>
> void assign_to(Functor f)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker9<tag> get_invoker;
> typedef typename get_invoker::
> template apply<Functor, R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to(f, functor)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
> template<typename Functor,typename Allocator>
> void assign_to_a(Functor f,Allocator a)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker9<tag> get_invoker;
> typedef typename get_invoker::
> template apply_a<Functor, R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8,
> Allocator>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to_a(f, functor, a)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<std::size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
>
>
>
> void move_assign(function9& f)
> {
> if (&f == this)
> return;
>
> { try {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::move_functor_tag);
> f.vtable = 0;
> } else {
> clear();
> }
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
> };
>
> template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
> inline void swap(function9<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >& f1,
> function9<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
> >& f2)
> {
> f1.swap(f2);
> }
>
>
>template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
> void operator==(const function9<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>&,
> const function9<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>&);
>template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
> void operator!=(const function9<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>&,
> const function9<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>& );
># 1046 "/usr/include/boost/function/function_template.hpp" 3 4
>template<typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
>class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)>
> : public function9<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
>{
> typedef function9<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> base_type;
> typedef function self_type;
>
> struct clear_type {};
>
>public:
>
> function() : base_type() {}
>
> template<typename Functor>
> function(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f)
> {
> }
> template<typename Functor,typename Allocator>
> function(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f,a)
> {
> }
>
>
> function(clear_type*) : base_type() {}
>
>
> function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
>
> function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
>
>
>
> function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
> function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
>
>
> self_type& operator=(const self_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(self_type&& f)
> {
> self_type(static_cast<self_type&&>(f)).swap(*this);
> return *this;
> }
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> self_type&>::type
>
>
>
> operator=(Functor f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
>
>
> self_type& operator=(const base_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(base_type&& f)
> {
> self_type(static_cast<base_type&&>(f)).swap(*this);
> return *this;
> }
>
>};
>
>
>
>
>}
># 59 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
># 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
># 93 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
># 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
># 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
># 63 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
># 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
># 81 "/usr/include/boost/function/function_template.hpp" 3 4
>namespace boost {
> namespace detail {
> namespace function {
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
> >
> struct function_invoker10
> {
> static R invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> return f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
> }
> };
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
> >
> struct void_function_invoker10
> {
> static void
> invoke(function_buffer& function_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
>
> {
> FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
> f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
> >
> struct function_obj_invoker10
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
> >
> struct void_function_obj_invoker10
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
>
> {
> FunctionObj* f;
> if (function_allows_small_object_optimization<FunctionObj>::value)
> f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
> else
> f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
> >
> struct function_ref_invoker10
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
> }
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
> >
> struct void_function_ref_invoker10
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
>
> {
> FunctionObj* f =
> reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
> (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
> }
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
> >
> struct function_mem_invoker10
> {
> static R invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
> }
> };
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
> >
> struct function_void_mem_invoker10
> {
> static void
> invoke(function_buffer& function_obj_ptr ,
> T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
>
> {
> MemberPtr* f =
> reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
> boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
> }
> };
>
>
> template<
> typename FunctionPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
> >
> struct get_function_invoker10
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_invoker10<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >,
> function_invoker10<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
> >
> struct get_function_obj_invoker10
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_obj_invoker10<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >,
> function_obj_invoker10<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >
> >::type type;
> };
>
> template<
> typename FunctionObj,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
> >
> struct get_function_ref_invoker10
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> void_function_ref_invoker10<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >,
> function_ref_invoker10<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >
> >::type type;
> };
>
>
>
> template<
> typename MemberPtr,
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
> >
> struct get_member_invoker10
> {
> typedef typename mpl::if_c<(is_void<R>::value),
> function_void_mem_invoker10<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >,
> function_mem_invoker10<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >
> >::type type;
> };
># 326 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename Tag>
> struct get_invoker10 { };
>
>
> template<>
> struct get_invoker10<function_ptr_tag>
> {
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
> struct apply
> {
> typedef typename get_function_invoker10<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
>
> template<typename FunctionPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_invoker10<
> FunctionPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker10<member_ptr_tag>
> {
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
> struct apply
> {
> typedef typename get_member_invoker10<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
>
> template<typename MemberPtr,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_member_invoker10<
> MemberPtr,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >::type
> invoker_type;
>
> typedef functor_manager<MemberPtr> manager_type;
> };
> };
>
>
>
> template<>
> struct get_invoker10<function_obj_tag>
> {
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
> struct apply
> {
> typedef typename get_function_obj_invoker10<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >::type
> invoker_type;
>
> typedef functor_manager<FunctionObj> manager_type;
> };
>
> template<typename FunctionObj,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_obj_invoker10<
> FunctionObj,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >::type
> invoker_type;
>
> typedef functor_manager_a<FunctionObj, Allocator> manager_type;
> };
> };
>
>
> template<>
> struct get_invoker10<function_obj_ref_tag>
> {
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
> struct apply
> {
> typedef typename get_function_ref_invoker10<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
>
> template<typename RefWrapper,
> typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
> typename Allocator>
> struct apply_a
> {
> typedef typename get_function_ref_invoker10<
> typename RefWrapper::type,
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >::type
> invoker_type;
>
> typedef reference_manager<typename RefWrapper::type> manager_type;
> };
> };
># 475 "/usr/include/boost/function/function_template.hpp" 3 4
> template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
> struct basic_vtable10
> {
>
> typedef R result_type;
>
>
>
>
> typedef result_type (*invoker_type)(function_buffer&
> ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9);
>
> template<typename F>
> bool assign_to(F f, function_buffer& functor) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to(f, functor, tag());
> }
> template<typename F,typename Allocator>
> bool assign_to_a(F f, function_buffer& functor, Allocator a) const
> {
> typedef typename get_function_tag<F>::type tag;
> return assign_to_a(f, functor, a, tag());
> }
>
> void clear(function_buffer& functor) const
> {
> if (base.manager)
> base.manager(functor, functor, destroy_functor_tag);
> }
>
> private:
>
> template<typename FunctionPtr>
> bool
> assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
> {
> this->clear(functor);
> if (f) {
>
>
> functor.func_ptr = reinterpret_cast<void (*)()>(f);
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionPtr,typename Allocator>
> bool
> assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
> {
> return assign_to(f,functor,function_ptr_tag());
> }
>
>
>
> template<typename MemberPtr>
> bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to(boost::mem_fn(f), functor);
> return true;
> } else {
> return false;
> }
> }
> template<typename MemberPtr,typename Allocator>
> bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
> {
>
>
>
> if (f) {
> this->assign_to_a(boost::mem_fn(f), functor, a);
> return true;
> } else {
> return false;
> }
> }
>
>
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
> {
> new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
> {
> assign_functor(f,functor,mpl::true_());
> }
>
>
> template<typename FunctionObj>
> void
> assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
> {
> functor.obj_ptr = new FunctionObj(f);
> }
> template<typename FunctionObj,typename Allocator>
> void
> assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
> {
> typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
> typedef typename Allocator::template rebind<functor_wrapper_type>::other
> wrapper_allocator_type;
> typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
> wrapper_allocator_type wrapper_allocator(a);
> wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
> wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
> functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
> functor.obj_ptr = new_f;
> }
>
> template<typename FunctionObj>
> bool
> assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor(f, functor,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
> {
> if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
> assign_functor_a(f, functor, a,
> mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
> return true;
> } else {
> return false;
> }
> }
>
>
> template<typename FunctionObj>
> bool
> assign_to(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, function_obj_ref_tag) const
> {
> functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
> functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
> functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
> return true;
> }
> template<typename FunctionObj,typename Allocator>
> bool
> assign_to_a(const reference_wrapper<FunctionObj>& f,
> function_buffer& functor, Allocator, function_obj_ref_tag) const
> {
> return assign_to(f,functor,function_obj_ref_tag());
> }
>
> public:
> vtable_base base;
> invoker_type invoker;
> };
> }
> }
>
> template<
> typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
> >
> class function10 : public function_base
># 664 "/usr/include/boost/function/function_template.hpp" 3 4
> {
> public:
>
> typedef R result_type;
>
>
>
>
>
> private:
> typedef boost::detail::function::basic_vtable10<
> R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
> vtable_type;
>
> vtable_type* get_vtable() const {
> return reinterpret_cast<vtable_type*>(
> reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
> }
>
> struct clear_type {};
>
> public:
> static const int args = 10;
>
>
> template<typename Args>
> struct sig
> {
> typedef result_type type;
> };
># 702 "/usr/include/boost/function/function_template.hpp" 3 4
> static const int arity = 10;
> typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; typedef T8 arg9_type; typedef T9 arg10_type;
>
> typedef function10 self_type;
>
> function10() : function_base() { }
>
>
>
> template<typename Functor>
> function10(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to(f);
> }
> template<typename Functor,typename Allocator>
> function10(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> function_base()
> {
> this->assign_to_a(f,a);
> }
>
>
> function10(clear_type*) : function_base() { }
>
>
>
>
>
>
>
> function10(const function10& f) : function_base()
> {
> this->assign_to_own(f);
> }
>
>
> function10(function10&& f) : function_base()
> {
> this->move_assign(f);
> }
>
>
> ~function10() { clear(); }
>
> result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9) const
> {
> if (this->empty())
> boost::throw_exception(bad_function_call());
>
> return get_vtable()->invoker
> (this->functor , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
> }
>
>
>
>
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> function10&>::type
>
>
>
> operator=(Functor f)
> {
> this->clear();
> { try {
> this->assign_to(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
> template<typename Functor,typename Allocator>
> void assign(Functor f, Allocator a)
> {
> this->clear();
> { try{
> this->assign_to_a(f,a);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
>
>
> function10& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
># 825 "/usr/include/boost/function/function_template.hpp" 3 4
> function10& operator=(const function10& f)
> {
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->assign_to_own(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
>
> function10& operator=(function10&& f)
> {
>
> if (&f == this)
> return *this;
>
> this->clear();
> { try {
> this->move_assign(f);
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> return *this;
> }
>
>
> void swap(function10& other)
> {
> if (&other == this)
> return;
>
> function10 tmp;
> tmp.move_assign(*this);
> this->move_assign(other);
> other.move_assign(tmp);
> }
>
>
> void clear()
> {
> if (vtable) {
> if (!this->has_trivial_copy_and_destroy())
> get_vtable()->clear(this->functor);
> vtable = 0;
> }
> }
>
>
>
>
>
> private:
> struct dummy {
> void nonnull() {}
> };
>
> typedef void (dummy::*safe_bool)();
>
> public:
> operator safe_bool () const
> { return (this->empty())? 0 : &dummy::nonnull; }
>
> bool operator!() const
> { return this->empty(); }
>
>
> private:
> void assign_to_own(const function10& f)
> {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::clone_functor_tag);
> }
> }
>
> template<typename Functor>
> void assign_to(Functor f)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker10<tag> get_invoker;
> typedef typename get_invoker::
> template apply<Functor, R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to(f, functor)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
> template<typename Functor,typename Allocator>
> void assign_to_a(Functor f,Allocator a)
> {
> using detail::function::vtable_base;
>
> typedef typename detail::function::get_function_tag<Functor>::type tag;
> typedef detail::function::get_invoker10<tag> get_invoker;
> typedef typename get_invoker::
> template apply_a<Functor, R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9,
> Allocator>
> handler_type;
>
> typedef typename handler_type::invoker_type invoker_type;
> typedef typename handler_type::manager_type manager_type;
>
>
>
>
>
> static const vtable_type stored_vtable =
> { { &manager_type::manage }, &invoker_type::invoke };
>
> if (stored_vtable.assign_to_a(f, functor, a)) {
> std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
> if (boost::has_trivial_copy_constructor<Functor>::value &&
> boost::has_trivial_destructor<Functor>::value &&
> detail::function::function_allows_small_object_optimization<Functor>::value)
> value |= static_cast<std::size_t>(0x01);
> vtable = reinterpret_cast<detail::function::vtable_base *>(value);
> } else
> vtable = 0;
> }
>
>
>
>
> void move_assign(function10& f)
> {
> if (&f == this)
> return;
>
> { try {
> if (!f.empty()) {
> this->vtable = f.vtable;
> if (this->has_trivial_copy_and_destroy())
> this->functor = f.functor;
> else
> get_vtable()->base.manager(f.functor, this->functor,
> boost::detail::function::move_functor_tag);
> f.vtable = 0;
> } else {
> clear();
> }
> } catch(...) {
> vtable = 0;
> throw;;
> }
> }
> }
> };
>
> template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
> inline void swap(function10<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >& f1,
> function10<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
> >& f2)
> {
> f1.swap(f2);
> }
>
>
>template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
> void operator==(const function10<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>&,
> const function10<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>&);
>template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
> void operator!=(const function10<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>&,
> const function10<
> R ,
> T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>& );
># 1046 "/usr/include/boost/function/function_template.hpp" 3 4
>template<typename R ,
> typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
>class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)>
> : public function10<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
>{
> typedef function10<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> base_type;
> typedef function self_type;
>
> struct clear_type {};
>
>public:
>
> function() : base_type() {}
>
> template<typename Functor>
> function(Functor f
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f)
> {
> }
> template<typename Functor,typename Allocator>
> function(Functor f, Allocator a
>
> ,typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> int>::type = 0
>
> ) :
> base_type(f,a)
> {
> }
>
>
> function(clear_type*) : base_type() {}
>
>
> function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
>
> function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
>
>
>
> function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
> function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
>
>
> self_type& operator=(const self_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(self_type&& f)
> {
> self_type(static_cast<self_type&&>(f)).swap(*this);
> return *this;
> }
>
>
> template<typename Functor>
>
> typename enable_if_c<
> (boost::type_traits::ice_not<
> (is_integral<Functor>::value)>::value),
> self_type&>::type
>
>
>
> operator=(Functor f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(clear_type*)
> {
> this->clear();
> return *this;
> }
>
>
> self_type& operator=(const base_type& f)
> {
> self_type(f).swap(*this);
> return *this;
> }
>
>
> self_type& operator=(base_type&& f)
> {
> self_type(static_cast<base_type&&>(f)).swap(*this);
> return *this;
> }
>
>};
>
>
>
>
>}
># 64 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
># 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
># 98 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
># 65 "/usr/include/boost/function.hpp" 2 3 4
># 40 "/usr/include/boost/thread/future.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/scoped_array.hpp" 1 3 4
># 14 "/usr/include/boost/scoped_array.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/scoped_array.hpp" 1 3 4
># 15 "/usr/include/boost/smart_ptr/scoped_array.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 16 "/usr/include/boost/smart_ptr/scoped_array.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 22 "/usr/include/boost/smart_ptr/scoped_array.hpp" 2 3 4
>
>namespace boost
>{
># 39 "/usr/include/boost/smart_ptr/scoped_array.hpp" 3 4
>template<class T> class scoped_array
>{
>private:
>
> T * px;
>
> scoped_array(scoped_array const &);
> scoped_array & operator=(scoped_array const &);
>
> typedef scoped_array<T> this_type;
>
> void operator==( scoped_array const& ) const;
> void operator!=( scoped_array const& ) const;
>
>public:
>
> typedef T element_type;
>
> explicit scoped_array( T * p = 0 ) noexcept : px( p )
> {
>
>
>
> }
>
> ~scoped_array()
> {
>
>
>
> boost::checked_array_delete( px );
> }
>
> void reset(T * p = 0)
> {
> ((void)0);
> this_type(p).swap(*this);
> }
>
> T & operator[](std::ptrdiff_t i) const
> {
> ((void)0);
> ((void)0);
> return px[i];
> }
>
> T * get() const noexcept
> {
> return px;
> }
>
>
># 1 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 1 3 4
># 11 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
> explicit operator bool () const noexcept
> {
> return px != 0;
> }
># 60 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
> bool operator! () const noexcept
> {
> return px == 0;
> }
># 92 "/usr/include/boost/smart_ptr/scoped_array.hpp" 2 3 4
>
> void swap(scoped_array & b) noexcept
> {
> T * tmp = b.px;
> b.px = px;
> px = tmp;
> }
>};
>
>
>
>template<class T> inline bool operator==( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) noexcept
>{
> return p.get() == 0;
>}
>
>template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) noexcept
>{
> return p.get() == 0;
>}
>
>template<class T> inline bool operator!=( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) noexcept
>{
> return p.get() != 0;
>}
>
>template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) noexcept
>{
> return p.get() != 0;
>}
>
>
>
>template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) noexcept
>{
> a.swap(b);
>}
>
>}
># 15 "/usr/include/boost/scoped_array.hpp" 2 3 4
># 43 "/usr/include/boost/thread/future.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/thread/future_error_code.hpp" 1 3 4
># 16 "/usr/include/boost/thread/future_error_code.hpp" 3 4
>namespace boost
>{
>
>
> enum class future_errc
> {
> broken_promise = 1,
> future_already_retrieved,
> promise_already_satisfied,
> no_state
> }
> ;
>
> namespace system
> {
> template <>
> struct __attribute__((__visibility__("default"))) is_error_code_enum<future_errc> : public true_type {};
>
>
>
>
>
> }
>
> __attribute__((__visibility__("default")))
> const system::error_category& future_category() noexcept;
>
> namespace system
> {
> inline
> error_code
> make_error_code(future_errc e) noexcept
> {
> return error_code(underlying_cast<int>(e), boost::future_category());
> }
>
> inline
> error_condition
> make_error_condition(future_errc e) noexcept
> {
> return error_condition(underlying_cast<int>(e), future_category());
> }
> }
>}
># 50 "/usr/include/boost/thread/future.hpp" 2 3 4
># 67 "/usr/include/boost/thread/future.hpp" 3 4
>namespace boost
>{
>
>
> enum class launch
> {
> none = 0,
> async = 1,
> deferred = 2,
> any = async | deferred
> }
> ;
>
>
> enum class future_status
> {
> ready,
> timeout,
> deferred
> }
> ;
>
> class __attribute__((__visibility__("default"))) future_error
> : public std::logic_error
> {
> system::error_code ec_;
> public:
> future_error(system::error_code ec)
> : logic_error(ec.message()),
> ec_(ec)
> {
> }
>
> const system::error_code& code() const noexcept
> {
> return ec_;
> }
> };
>
> class __attribute__((__visibility__("default"))) future_uninitialized:
> public future_error
> {
> public:
> future_uninitialized() :
> future_error(system::make_error_code(future_errc::no_state))
> {}
> };
> class __attribute__((__visibility__("default"))) broken_promise:
> public future_error
> {
> public:
> broken_promise():
> future_error(system::make_error_code(future_errc::broken_promise))
> {}
> };
> class __attribute__((__visibility__("default"))) future_already_retrieved:
> public future_error
> {
> public:
> future_already_retrieved():
> future_error(system::make_error_code(future_errc::future_already_retrieved))
> {}
> };
> class __attribute__((__visibility__("default"))) promise_already_satisfied:
> public future_error
> {
> public:
> promise_already_satisfied():
> future_error(system::make_error_code(future_errc::promise_already_satisfied))
> {}
> };
>
> class __attribute__((__visibility__("default"))) task_already_started:
> public future_error
> {
> public:
> task_already_started():
> future_error(system::make_error_code(future_errc::promise_already_satisfied))
> {}
> };
>
> class __attribute__((__visibility__("default"))) task_moved:
> public future_error
> {
> public:
> task_moved():
> future_error(system::make_error_code(future_errc::no_state))
> {}
> };
>
> class promise_moved:
> public future_error
> {
> public:
> promise_moved():
> future_error(system::make_error_code(future_errc::no_state))
> {}
> };
>
> namespace future_state
> {
> enum state { uninitialized, waiting, ready, moved, deferred };
> }
>
> namespace detail
> {
>
>
>
>
>
>
>
> struct relocker
> {
> boost::unique_lock<boost::mutex>& lock_;
> bool unlocked_;
>
> relocker(boost::unique_lock<boost::mutex>& lk):
> lock_(lk)
> {
> lock_.unlock();
> unlocked_=true;
> }
> ~relocker()
> {
> if (unlocked_) {
> lock_.lock();
> }
> }
> void lock() {
> if (unlocked_) {
> lock_.lock();
> unlocked_=false;
> }
> }
> private:
> relocker& operator=(relocker const&);
> };
>
> struct future_object_base : enable_shared_from_this<future_object_base>
> {
>
> boost::exception_ptr exception;
> bool done;
> bool is_deferred_;
> launch policy_;
> bool is_constructed;
> boost::mutex mutex;
> boost::condition_variable waiters;
> typedef std::list<boost::condition_variable_any*> waiter_list;
> waiter_list external_waiters;
> boost::function<void()> callback;
>
> bool thread_was_interrupted;
>
>
>
>
> typedef shared_ptr<void> continuation_ptr_type;
>
> continuation_ptr_type continuation_ptr;
>
>
>
> virtual void launch_continuation(boost::unique_lock<boost::mutex>&)
> {
> }
>
> future_object_base():
> done(false),
> is_deferred_(false),
> policy_(launch::none),
> is_constructed(false)
>
>
>
> , thread_was_interrupted(false)
>
>
>
> , continuation_ptr()
>
> {}
> virtual ~future_object_base()
> {}
>
> void set_deferred()
> {
> is_deferred_ = true;
> set_launch_policy(launch::deferred);
> }
> void set_async()
> {
> is_deferred_ = false;
> set_launch_policy(launch::async);
> }
> void set_launch_policy(launch policy)
> {
> policy_ = policy;
> }
>
> waiter_list::iterator register_external_waiter(boost::condition_variable_any& cv)
> {
> boost::unique_lock<boost::mutex> lock(mutex);
> do_callback(lock);
> return external_waiters.insert(external_waiters.end(),&cv);
> }
>
> void remove_external_waiter(waiter_list::iterator it)
> {
> boost::lock_guard<boost::mutex> lock(mutex);
> external_waiters.erase(it);
> }
># 293 "/usr/include/boost/thread/future.hpp" 3 4
> void do_continuation(boost::unique_lock<boost::mutex>&)
> {
> }
># 306 "/usr/include/boost/thread/future.hpp" 3 4
> void mark_finished_internal(boost::unique_lock<boost::mutex>& lock)
> {
> done=true;
> waiters.notify_all();
> for(waiter_list::const_iterator it=external_waiters.begin(),
> end=external_waiters.end();it!=end;++it)
> {
> (*it)->notify_all();
> }
> do_continuation(lock);
> }
> void make_ready()
> {
> boost::unique_lock<boost::mutex> lock(mutex);
> mark_finished_internal(lock);
> }
>
> void do_callback(boost::unique_lock<boost::mutex>& lock)
> {
> if(callback && !done)
> {
> boost::function<void()> local_callback=callback;
> relocker relock(lock);
> local_callback();
> }
> }
>
>
> void wait_internal(boost::unique_lock<boost::mutex> &lock, bool rethrow=true)
> {
> do_callback(lock);
>
> {
> if (is_deferred_)
> {
> is_deferred_=false;
> execute(lock);
>
> }
> else
> {
> while(!done)
> {
> waiters.wait(lock);
> }
>
> if(rethrow && thread_was_interrupted)
> {
> throw boost::thread_interrupted();
> }
>
> if(rethrow && exception)
> {
> boost::rethrow_exception(exception);
> }
> }
> }
> }
> void wait(bool rethrow=true)
> {
> boost::unique_lock<boost::mutex> lock(mutex);
> wait_internal(lock, rethrow);
> }
>
>
> bool timed_wait_until(boost::system_time const& target_time)
> {
> boost::unique_lock<boost::mutex> lock(mutex);
> if (is_deferred_)
> return false;
>
> do_callback(lock);
> while(!done)
> {
> bool const success=waiters.timed_wait(lock,target_time);
> if(!success && !done)
> {
> return false;
> }
> }
> return true;
> }
>
>
>
> template <class Clock, class Duration>
> future_status
> wait_until(const chrono::time_point<Clock, Duration>& abs_time)
> {
> boost::unique_lock<boost::mutex> lock(mutex);
> if (is_deferred_)
> return future_status::deferred;
> do_callback(lock);
> while(!done)
> {
> cv_status const st=waiters.wait_until(lock,abs_time);
> if(st==cv_status::timeout && !done)
> {
> return future_status::timeout;
> }
> }
> return future_status::ready;
> }
>
> void mark_exceptional_finish_internal(boost::exception_ptr const& e, boost::unique_lock<boost::mutex>& lock)
> {
> exception=e;
> mark_finished_internal(lock);
> }
> void mark_exceptional_finish()
> {
> boost::unique_lock<boost::mutex> lock(mutex);
> mark_exceptional_finish_internal(boost::current_exception(), lock);
> }
>
> void mark_interrupted_finish()
> {
> boost::unique_lock<boost::mutex> lock(mutex);
> thread_was_interrupted=true;
> mark_finished_internal(lock);
> }
> void set_interrupted_at_thread_exit()
> {
> unique_lock<boost::mutex> lk(mutex);
> thread_was_interrupted=true;
> if (has_value(lk))
> {
> throw_exception(promise_already_satisfied());
> }
> get_current_thread_data()->make_ready_at_thread_exit(shared_from_this());
> }
>
> void set_exception_at_thread_exit(exception_ptr e)
> {
> unique_lock<boost::mutex> lk(mutex);
> if (has_value(lk))
> {
> throw_exception(promise_already_satisfied());
> }
> exception=e;
> this->is_constructed = true;
> get_current_thread_data()->make_ready_at_thread_exit(shared_from_this());
> }
> bool has_value()
> {
> boost::lock_guard<boost::mutex> lock(mutex);
> return done && !(exception
>
> || thread_was_interrupted
>
> );
> }
> bool has_value(unique_lock<boost::mutex>& )
> {
> return done && !(exception
>
> || thread_was_interrupted
>
> );
> }
> bool has_exception()
> {
> boost::lock_guard<boost::mutex> lock(mutex);
> return done && (exception
>
> || thread_was_interrupted
>
> );
> }
> bool has_exception(unique_lock<boost::mutex>&)
> {
> return done && (exception
>
> || thread_was_interrupted
>
> );
> }
> bool is_deferred() const noexcept {
> return is_deferred_;
> }
>
> launch launch_policy() const noexcept
> {
> return policy_;
> }
>
> template<typename F,typename U>
> void set_wait_callback(F f,U* u)
> {
> boost::lock_guard<boost::mutex> lock(mutex);
> callback=boost::bind(f,boost::ref(*u));
> }
> virtual void execute(boost::unique_lock<boost::mutex>&) {}
>
> private:
> future_object_base(future_object_base const&);
> future_object_base& operator=(future_object_base const&);
> };
>
> template<typename T>
> struct future_traits
> {
> typedef boost::scoped_ptr<T> storage_type;
> struct dummy;
>
> typedef T const& source_reference_type;
>
> typedef T && rvalue_source_type;
>
> typedef T move_dest_type;
># 529 "/usr/include/boost/thread/future.hpp" 3 4
> typedef const T& shared_future_get_result_type;
>
> static void init(storage_type& storage,source_reference_type t)
> {
> storage.reset(new T(t));
> }
>
> static void init(storage_type& storage,rvalue_source_type t)
> {
>
> storage.reset(new T(boost::forward<T>(t)));
>
>
>
> }
>
> static void cleanup(storage_type& storage)
> {
> storage.reset();
> }
> };
>
> template<typename T>
> struct future_traits<T&>
> {
> typedef T* storage_type;
> typedef T& source_reference_type;
>
>
> typedef T& move_dest_type;
> typedef T& shared_future_get_result_type;
>
> static void init(storage_type& storage,T& t)
> {
> storage=&t;
> }
>
> static void cleanup(storage_type& storage)
> {
> storage=0;
> }
> };
>
> template<>
> struct future_traits<void>
> {
> typedef bool storage_type;
> typedef void move_dest_type;
> typedef void shared_future_get_result_type;
>
> static void init(storage_type& storage)
> {
> storage=true;
> }
>
> static void cleanup(storage_type& storage)
> {
> storage=false;
> }
>
> };
>
>
> template<typename T>
> struct future_object:
> detail::future_object_base
> {
> typedef typename future_traits<T>::storage_type storage_type;
> typedef typename future_traits<T>::source_reference_type source_reference_type;
> typedef typename future_traits<T>::rvalue_source_type rvalue_source_type;
> typedef typename future_traits<T>::move_dest_type move_dest_type;
> typedef typename future_traits<T>::shared_future_get_result_type shared_future_get_result_type;
>
> storage_type result;
>
> future_object():
> result(0)
> {}
>
> ~future_object()
> {}
>
> void mark_finished_with_result_internal(source_reference_type result_, boost::unique_lock<boost::mutex>& lock)
> {
> future_traits<T>::init(result,result_);
> this->mark_finished_internal(lock);
> }
>
> void mark_finished_with_result_internal(rvalue_source_type result_, boost::unique_lock<boost::mutex>& lock)
> {
>
> future_traits<T>::init(result,boost::forward<T>(result_));
>
>
>
> this->mark_finished_internal(lock);
> }
>
> void mark_finished_with_result(source_reference_type result_)
> {
> boost::unique_lock<boost::mutex> lock(mutex);
> this->mark_finished_with_result_internal(result_, lock);
> }
>
> void mark_finished_with_result(rvalue_source_type result_)
> {
> boost::unique_lock<boost::mutex> lock(mutex);
>
>
> mark_finished_with_result_internal(boost::forward<T>(result_), lock);
>
>
>
> }
>
>
> virtual move_dest_type get()
> {
> wait();
> return boost::move(*result);
> }
>
> shared_future_get_result_type get_sh()
> {
> wait();
> return *result;
> }
>
>
> future_state::state get_state()
> {
> boost::lock_guard<boost::mutex> guard(mutex);
> if(!done)
> {
> return future_state::waiting;
> }
> else
> {
> return future_state::ready;
> }
> }
>
>
>
> void set_value_at_thread_exit(source_reference_type result_)
> {
> unique_lock<boost::mutex> lk(this->mutex);
> if (this->has_value(lk))
> {
> throw_exception(promise_already_satisfied());
> }
>
> result.reset(new T(result_));
>
> this->is_constructed = true;
> get_current_thread_data()->make_ready_at_thread_exit(shared_from_this());
> }
>
> void set_value_at_thread_exit(rvalue_source_type result_)
> {
> unique_lock<boost::mutex> lk(this->mutex);
> if (this->has_value(lk))
> throw_exception(promise_already_satisfied());
> result.reset(new T(boost::move(result_)));
>
> this->is_constructed = true;
> get_current_thread_data()->make_ready_at_thread_exit(shared_from_this());
> }
>
>
> private:
> future_object(future_object const&);
> future_object& operator=(future_object const&);
> };
>
> template<typename T>
> struct future_object<T&>:
> detail::future_object_base
> {
> typedef typename future_traits<T&>::storage_type storage_type;
> typedef typename future_traits<T&>::source_reference_type source_reference_type;
>
> typedef typename future_traits<T&>::move_dest_type move_dest_type;
> typedef typename future_traits<T&>::shared_future_get_result_type shared_future_get_result_type;
>
> T* result;
>
> future_object():
> result(0)
> {}
>
> ~future_object()
> {
> }
>
> void mark_finished_with_result_internal(source_reference_type result_, boost::unique_lock<boost::mutex>& lock)
> {
>
> result= &result_;
> mark_finished_internal(lock);
> }
>
>
>
>
>
>
>
> void mark_finished_with_result(source_reference_type result_)
> {
> boost::unique_lock<boost::mutex> lock(mutex);
> mark_finished_with_result_internal(result_, lock);
> }
># 750 "/usr/include/boost/thread/future.hpp" 3 4
> T& get()
> {
> wait();
>
> return *result;
> }
>
> T& get_sh()
> {
> wait();
>
> return *result;
> }
>
>
> future_state::state get_state()
> {
> boost::lock_guard<boost::mutex> guard(mutex);
> if(!done)
> {
> return future_state::waiting;
> }
> else
> {
> return future_state::ready;
> }
> }
>
> void set_value_at_thread_exit(T& result_)
> {
> unique_lock<boost::mutex> lk(this->mutex);
> if (this->has_value(lk))
> throw_exception(promise_already_satisfied());
>
> result= &result_;
> this->is_constructed = true;
> get_current_thread_data()->make_ready_at_thread_exit(shared_from_this());
> }
># 799 "/usr/include/boost/thread/future.hpp" 3 4
> private:
> future_object(future_object const&);
> future_object& operator=(future_object const&);
> };
>
> template<>
> struct future_object<void>:
> detail::future_object_base
> {
> typedef void shared_future_get_result_type;
>
> future_object()
> {}
>
> void mark_finished_with_result_internal(boost::unique_lock<boost::mutex>& lock)
> {
> mark_finished_internal(lock);
> }
>
> void mark_finished_with_result()
> {
> boost::unique_lock<boost::mutex> lock(mutex);
> mark_finished_with_result_internal(lock);
> }
>
> void get()
> {
> this->wait();
> }
> void get_sh()
> {
> wait();
> }
>
> future_state::state get_state()
> {
> boost::lock_guard<boost::mutex> guard(mutex);
> if(!done)
> {
> return future_state::waiting;
> }
> else
> {
> return future_state::ready;
> }
> }
> void set_value_at_thread_exit()
> {
> unique_lock<boost::mutex> lk(this->mutex);
> if (this->has_value(lk))
> {
> throw_exception(promise_already_satisfied());
> }
> this->is_constructed = true;
> get_current_thread_data()->make_ready_at_thread_exit(shared_from_this());
> }
> private:
> future_object(future_object const&);
> future_object& operator=(future_object const&);
> };
>
>
>
>
> template<typename Rp, typename Fp>
> struct future_async_object: future_object<Rp>
> {
> typedef future_object<Rp> base_type;
> typedef typename base_type::move_dest_type move_dest_type;
>
> boost::thread thr_;
>
> public:
> explicit future_async_object(Fp && f) :
> thr_(&future_async_object::run, this, boost::forward<Fp>(f))
> {
> this->set_async();
> }
>
> ~future_async_object()
> {
> if (thr_.joinable()) thr_.join();
> }
>
> move_dest_type get()
> {
> if (thr_.joinable()) thr_.join();
>
>
> boost::unique_lock<boost::mutex> lock(this->mutex);
> this->wait_internal(lock);
>
>
>
> return boost::move(*(this->result));
> }
> static void run(future_async_object* that, Fp && f)
> {
> try
> {
> that->mark_finished_with_result(f());
> }
>
> catch(thread_interrupted& )
> {
> that->mark_interrupted_finish();
> }
>
> catch(...)
> {
> that->mark_exceptional_finish();
> }
> }
> };
>
> template<typename Fp>
> struct future_async_object<void, Fp>: public future_object<void>
> {
> typedef future_object<void> base_type;
> boost::thread thr_;
>
> public:
> explicit future_async_object(Fp && f) :
> thr_(&future_async_object::run, this, boost::forward<Fp>(f))
> {
> this->set_async();
> }
>
> ~future_async_object()
> {
> if (thr_.joinable()) thr_.join();
> }
>
> static void run(future_async_object* that, Fp && f)
> {
> try
> {
> f();
> that->mark_finished_with_result();
> }
>
> catch(thread_interrupted& )
> {
> that->mark_interrupted_finish();
> }
>
> catch(...)
> {
> that->mark_exceptional_finish();
> }
> }
> };
>
> template<typename Rp, typename Fp>
> struct future_async_object<Rp&, Fp>: future_object<Rp&>
> {
> typedef future_object<Rp&> base_type;
> typedef typename base_type::move_dest_type move_dest_type;
>
> boost::thread thr_;
>
> public:
> explicit future_async_object(Fp && f) :
> thr_(&future_async_object::run, this, boost::forward<Fp>(f))
> {
> this->set_async();
> }
>
> ~future_async_object()
> {
> if (thr_.joinable()) thr_.join();
> }
>
> move_dest_type get()
> {
> if (thr_.joinable()) thr_.join();
>
>
> boost::unique_lock<boost::mutex> lock(this->mutex);
> this->wait_internal(lock);
>
>
> return boost::move(*(this->result));
> }
> static void run(future_async_object* that, Fp && f)
> {
> try
> {
> that->mark_finished_with_result(f());
> }
>
> catch(thread_interrupted& )
> {
> that->mark_interrupted_finish();
> }
>
> catch(...)
> {
> that->mark_exceptional_finish();
> }
> }
> };
>
>
>
>
> template<typename Rp, typename Fp>
> struct future_deferred_object: future_object<Rp>
> {
> typedef future_object<Rp> base_type;
> Fp func_;
>
> public:
> explicit future_deferred_object(Fp && f)
> : func_(boost::forward<Fp>(f))
> {
> this->set_deferred();
> }
>
> virtual void execute(boost::unique_lock<boost::mutex>& lck) {
> try
> {
> this->mark_finished_with_result_internal(func_(), lck);
> }
> catch (...)
> {
> this->mark_exceptional_finish_internal(current_exception(), lck);
> }
> }
> };
> template<typename Rp, typename Fp>
> struct future_deferred_object<Rp&,Fp>: future_object<Rp&>
> {
> typedef future_object<Rp&> base_type;
> Fp func_;
>
> public:
> explicit future_deferred_object(Fp && f)
> : func_(boost::forward<Fp>(f))
> {
> this->set_deferred();
> }
>
> virtual void execute(boost::unique_lock<boost::mutex>& lck) {
> try
> {
> this->mark_finished_with_result_internal(func_(), lck);
> }
> catch (...)
> {
> this->mark_exceptional_finish_internal(current_exception(), lck);
> }
> }
> };
>
> template<typename Fp>
> struct future_deferred_object<void,Fp>: future_object<void>
> {
> typedef future_object<void> base_type;
> Fp func_;
>
> public:
> explicit future_deferred_object(Fp && f)
> : func_(boost::forward<Fp>(f))
> {
> this->set_deferred();
> }
>
> virtual void execute(boost::unique_lock<boost::mutex>& lck) {
> try
> {
> func_();
> this->mark_finished_with_result_internal(lck);
> }
> catch (...)
> {
> this->mark_exceptional_finish_internal(current_exception(), lck);
> }
> }
> };
># 1091 "/usr/include/boost/thread/future.hpp" 3 4
> class future_waiter
> {
> struct registered_waiter;
> typedef std::vector<int>::size_type count_type;
>
> struct registered_waiter
> {
> boost::shared_ptr<detail::future_object_base> future_;
> detail::future_object_base::waiter_list::iterator wait_iterator;
> count_type index;
>
> registered_waiter(boost::shared_ptr<detail::future_object_base> const& a_future,
> detail::future_object_base::waiter_list::iterator wait_iterator_,
> count_type index_):
> future_(a_future),wait_iterator(wait_iterator_),index(index_)
> {}
> };
>
> struct all_futures_lock
> {
>
>
>
> typedef count_type count_type_portable;
>
> count_type_portable count;
> boost::scoped_array<boost::unique_lock<boost::mutex> > locks;
>
> all_futures_lock(std::vector<registered_waiter>& futures):
> count(futures.size()),locks(new boost::unique_lock<boost::mutex>[count])
> {
> for(count_type_portable i=0;i<count;++i)
> {
>
>
>
> locks[i]=boost::unique_lock<boost::mutex>(futures[i].future_->mutex);
>
> }
> }
>
> void lock()
> {
> boost::lock(locks.get(),locks.get()+count);
> }
>
> void unlock()
> {
> for(count_type_portable i=0;i<count;++i)
> {
> locks[i].unlock();
> }
> }
> };
>
> boost::condition_variable_any cv;
> std::vector<registered_waiter> futures;
> count_type future_count;
>
> public:
> future_waiter():
> future_count(0)
> {}
>
> template<typename F>
> void add(F& f)
> {
> if(f.future_)
> {
> futures.push_back(registered_waiter(f.future_,f.future_->register_external_waiter(cv),future_count));
> }
> ++future_count;
> }
>
> count_type wait()
> {
> all_futures_lock lk(futures);
> for(;;)
> {
> for(count_type i=0;i<futures.size();++i)
> {
> if(futures[i].future_->done)
> {
> return futures[i].index;
> }
> }
> cv.wait(lk);
> }
> }
>
> ~future_waiter()
> {
> for(count_type i=0;i<futures.size();++i)
> {
> futures[i].future_->remove_external_waiter(futures[i].wait_iterator);
> }
> }
>
> };
>
> }
>
> template <typename R>
> class unique_future;
>
> template <typename R>
> class shared_future;
>
> template<typename T>
> struct is_future_type
> {
> static const bool value=false;
> };
>
> template<typename T>
> struct is_future_type<unique_future<T> >
> {
> static const bool value=true;
> };
>
> template<typename T>
> struct is_future_type<shared_future<T> >
> {
> static const bool value=true;
> };
>
> template<typename Iterator>
> typename boost::disable_if<is_future_type<Iterator>,void>::type wait_for_all(Iterator begin,Iterator end)
> {
> for(Iterator current=begin;current!=end;++current)
> {
> current->wait();
> }
> }
>
> template<typename F1,typename F2>
> typename boost::enable_if<is_future_type<F1>,void>::type wait_for_all(F1& f1,F2& f2)
> {
> f1.wait();
> f2.wait();
> }
>
> template<typename F1,typename F2,typename F3>
> void wait_for_all(F1& f1,F2& f2,F3& f3)
> {
> f1.wait();
> f2.wait();
> f3.wait();
> }
>
> template<typename F1,typename F2,typename F3,typename F4>
> void wait_for_all(F1& f1,F2& f2,F3& f3,F4& f4)
> {
> f1.wait();
> f2.wait();
> f3.wait();
> f4.wait();
> }
>
> template<typename F1,typename F2,typename F3,typename F4,typename F5>
> void wait_for_all(F1& f1,F2& f2,F3& f3,F4& f4,F5& f5)
> {
> f1.wait();
> f2.wait();
> f3.wait();
> f4.wait();
> f5.wait();
> }
>
> template<typename Iterator>
> typename boost::disable_if<is_future_type<Iterator>,Iterator>::type wait_for_any(Iterator begin,Iterator end)
> {
> if(begin==end)
> return end;
>
> detail::future_waiter waiter;
> for(Iterator current=begin;current!=end;++current)
> {
> waiter.add(*current);
> }
> return boost::next(begin,waiter.wait());
> }
>
> template<typename F1,typename F2>
> typename boost::enable_if<is_future_type<F1>,unsigned>::type wait_for_any(F1& f1,F2& f2)
> {
> detail::future_waiter waiter;
> waiter.add(f1);
> waiter.add(f2);
> return waiter.wait();
> }
>
> template<typename F1,typename F2,typename F3>
> unsigned wait_for_any(F1& f1,F2& f2,F3& f3)
> {
> detail::future_waiter waiter;
> waiter.add(f1);
> waiter.add(f2);
> waiter.add(f3);
> return waiter.wait();
> }
>
> template<typename F1,typename F2,typename F3,typename F4>
> unsigned wait_for_any(F1& f1,F2& f2,F3& f3,F4& f4)
> {
> detail::future_waiter waiter;
> waiter.add(f1);
> waiter.add(f2);
> waiter.add(f3);
> waiter.add(f4);
> return waiter.wait();
> }
>
> template<typename F1,typename F2,typename F3,typename F4,typename F5>
> unsigned wait_for_any(F1& f1,F2& f2,F3& f3,F4& f4,F5& f5)
> {
> detail::future_waiter waiter;
> waiter.add(f1);
> waiter.add(f2);
> waiter.add(f3);
> waiter.add(f4);
> waiter.add(f5);
> return waiter.wait();
> }
>
> template <typename R>
> class promise;
>
> template <typename R>
> class packaged_task;
>
> namespace detail
> {
>
> class base_future
> {
>
>
> };
>
> template <typename R>
> class basic_future : public base_future
> {
> protected:
>
> typedef boost::shared_ptr<detail::future_object<R> > future_ptr;
>
> future_ptr future_;
>
> basic_future(future_ptr a_future):
> future_(a_future)
> {
> }
>
> explicit basic_future(const shared_future<R>&) noexcept;
>
> public:
> typedef future_state::state state;
>
> 
> basic_future(): future_() {}
> ~basic_future() {}
>
> basic_future(basic_future && other) noexcept:
> future_(other.future_)
> {
> other.future_.reset();
> }
> basic_future& operator=(basic_future && other) noexcept
> {
> future_=other.future_;
> other.future_.reset();
> return *this;
> }
> void swap(basic_future& that) noexcept
> {
> future_.swap(that.future_);
> }
>
> state get_state() const noexcept
> {
> if(!future_)
> {
> return future_state::uninitialized;
> }
> return future_->get_state();
> }
>
> bool is_ready() const noexcept
> {
> return get_state()==future_state::ready;
> }
>
> bool has_exception() const noexcept
> {
> return future_ && future_->has_exception();
> }
>
> bool has_value() const noexcept
> {
> return future_ && future_->has_value();
> }
>
> launch launch_policy() const noexcept
> {
> if ( future_ ) return future_->launch_policy();
> else return launch(launch::none);
> }
>
> bool valid() const noexcept
> {
> return future_ != 0;
> }
>
>
> void wait() const
> {
> if(!future_)
> {
> boost::throw_exception(future_uninitialized());
> }
> future_->wait(false);
> }
>
>
> template<typename Duration>
> bool timed_wait(Duration const& rel_time) const
> {
> return timed_wait_until(boost::get_system_time()+rel_time);
> }
>
> bool timed_wait_until(boost::system_time const& abs_time) const
> {
> if(!future_)
> {
> boost::throw_exception(future_uninitialized());
> }
> return future_->timed_wait_until(abs_time);
> }
>
>
> template <class Rep, class Period>
> future_status
> wait_for(const chrono::duration<Rep, Period>& rel_time) const
> {
> return wait_until(chrono::steady_clock::now() + rel_time);
>
> }
> template <class Clock, class Duration>
> future_status
> wait_until(const chrono::time_point<Clock, Duration>& abs_time) const
> {
> if(!future_)
> {
> boost::throw_exception(future_uninitialized());
> }
> return future_->wait_until(abs_time);
> }
>
>
> };
>
> }
> namespace detail { template <typename R> struct enable_move_utility_emulation_dummy_specialization< detail::basic_future<R> > : integral_constant<bool, false> {}; }
>
> namespace detail
> {
>
> template <class Rp, class Fp>
> unique_future<Rp>
> make_future_async_object(Fp && f);
>
> template <class Rp, class Fp>
> unique_future<Rp>
> make_future_deferred_object(Fp && f);
># 1478 "/usr/include/boost/thread/future.hpp" 3 4
> }
>
> template <typename R>
> class unique_future : public detail::basic_future<R>
> {
> private:
> typedef detail::basic_future<R> base_type;
> typedef typename base_type::future_ptr future_ptr;
>
> friend class shared_future<R>;
> friend class promise<R>;
># 1498 "/usr/include/boost/thread/future.hpp" 3 4
> friend class packaged_task<R>;
>
> friend class detail::future_waiter;
>
> template <class Rp, class Fp>
> friend unique_future<Rp>
> detail::make_future_async_object(Fp && f);
>
> template <class Rp, class Fp>
> friend unique_future<Rp>
> detail::make_future_deferred_object(Fp && f);
># 1520 "/usr/include/boost/thread/future.hpp" 3 4
> typedef typename detail::future_traits<R>::move_dest_type move_dest_type;
>
> unique_future(future_ptr a_future):
> base_type(a_future)
> {
> }
>
> public:
> unique_future(unique_future const&) = delete; unique_future& operator=(unique_future const&) = delete;
> typedef future_state::state state;
>
> constexpr unique_future() {}
>
> ~unique_future() {}
>
> unique_future(unique_future && other) noexcept:
> base_type(boost::move(static_cast<base_type&>(other)))
> {
> }
>
> unique_future& operator=(unique_future && other) noexcept
> {
> this->base_type::operator=(boost::move(static_cast<base_type&>(other)));
> return *this;
> }
>
> shared_future<R> share()
> {
> return shared_future<R>(::boost::move(*this));
> }
>
> void swap(unique_future& other)
> {
> static_cast<base_type*>(this)->swap(other);
> }
>
>
> void set_async()
> {
> this->future_->set_async();
> }
>
> void set_deferred()
> {
> this->future_->set_deferred();
> }
>
>
> move_dest_type get()
> {
> if(!this->future_)
> {
> boost::throw_exception(future_uninitialized());
> }
>
>
>
>
>
>
> return this->future_->get();
>
> }
># 1603 "/usr/include/boost/thread/future.hpp" 3 4
> };
>
> namespace detail { template <typename T> struct enable_move_utility_emulation_dummy_specialization< unique_future<T> > : integral_constant<bool, false> {}; }
>
> template <typename R>
> class shared_future : public detail::basic_future<R>
> {
>
> typedef detail::basic_future<R> base_type;
> typedef typename base_type::future_ptr future_ptr;
>
> friend class detail::future_waiter;
> friend class promise<R>;
>
>
>
>
> friend class packaged_task<R>;
>
> shared_future(future_ptr a_future):
> base_type(a_future)
> {}
>
> public:
> 
>
> shared_future(shared_future const& other):
> base_type(other)
> {}
>
> typedef future_state::state state;
>
> constexpr shared_future()
> {}
>
> ~shared_future()
> {}
>
> shared_future& operator=(shared_future const& other)
> {
> shared_future(other).swap(*this);
> return *this;
> }
> shared_future(shared_future && other) noexcept :
> base_type(boost::move(static_cast<base_type&>(other)))
> {
> other.future_.reset();
> }
> shared_future(unique_future<R> && other) noexcept :
> base_type(boost::move(static_cast<base_type&>(other)))
> {
> }
>
> shared_future& operator=(shared_future && other) noexcept
> {
> base_type::operator=(boost::move(static_cast<base_type&>(other)));
> return *this;
> }
> shared_future& operator=(unique_future<R> && other) noexcept
> {
> base_type::operator=(boost::move(static_cast<base_type&>(other)));
>
>
>
> return *this;
> }
>
> void swap(shared_future& other) noexcept
> {
> static_cast<base_type*>(this)->swap(other);
> }
>
>
> typename detail::future_object<R>::shared_future_get_result_type get()
> {
> if(!this->future_)
> {
> boost::throw_exception(future_uninitialized());
> }
>
> return this->future_->get_sh();
> }
>
> };
>
> namespace detail { template <typename T> struct enable_move_utility_emulation_dummy_specialization< shared_future<T> > : integral_constant<bool, false> {}; }
>
> namespace detail
> {
>
> template <typename R>
> inline basic_future<R>::basic_future(const shared_future<R>& other) noexcept
> : future_(other.future_)
> {
> }
> }
>
> template <typename R>
> class promise
> {
> typedef boost::shared_ptr<detail::future_object<R> > future_ptr;
>
> future_ptr future_;
> bool future_obtained;
>
> void lazy_init()
> {
>
># 1 "/usr/include/boost/detail/atomic_undef_macros.hpp" 1 3 4
># 1712 "/usr/include/boost/thread/future.hpp" 2 3 4
> if(!atomic_load(&future_))
> {
> future_ptr blank;
> atomic_compare_exchange(&future_,&blank,future_ptr(new detail::future_object<R>));
> }
># 1 "/usr/include/boost/detail/atomic_redef_macros.hpp" 1 3 4
># 1718 "/usr/include/boost/thread/future.hpp" 2 3 4
>
> }
>
> public:
> promise(promise const&) = delete; promise& operator=(promise const&) = delete;
># 1735 "/usr/include/boost/thread/future.hpp" 3 4
> promise():
>
> future_(),
>
>
>
> future_obtained(false)
> {}
>
> ~promise()
> {
> if(future_)
> {
> boost::unique_lock<boost::mutex> lock(future_->mutex);
>
> if(!future_->done && !future_->is_constructed)
> {
> future_->mark_exceptional_finish_internal(boost::copy_exception(broken_promise()), lock);
> }
> }
> }
>
>
> promise(promise && rhs) noexcept :
> future_(rhs.future_),future_obtained(rhs.future_obtained)
> {
> rhs.future_.reset();
> rhs.future_obtained=false;
> }
> promise & operator=(promise && rhs) noexcept
> {
> future_=rhs.future_;
> future_obtained=rhs.future_obtained;
> rhs.future_.reset();
> rhs.future_obtained=false;
> return *this;
> }
>
> void swap(promise& other)
> {
> future_.swap(other.future_);
> std::swap(future_obtained,other.future_obtained);
> }
>
>
> unique_future<R> get_future()
> {
> lazy_init();
> if (future_.get()==0)
> {
> boost::throw_exception(promise_moved());
> }
> if (future_obtained)
> {
> boost::throw_exception(future_already_retrieved());
> }
> future_obtained=true;
> return unique_future<R>(future_);
> }
>
> void set_value(typename detail::future_traits<R>::source_reference_type r)
> {
> lazy_init();
> boost::unique_lock<boost::mutex> lock(future_->mutex);
> if(future_->done)
> {
> boost::throw_exception(promise_already_satisfied());
> }
> future_->mark_finished_with_result_internal(r, lock);
> }
>
>
> void set_value(typename detail::future_traits<R>::rvalue_source_type r)
> {
> lazy_init();
> boost::unique_lock<boost::mutex> lock(future_->mutex);
> if(future_->done)
> {
> boost::throw_exception(promise_already_satisfied());
> }
>
> future_->mark_finished_with_result_internal(boost::forward<R>(r), lock);
>
>
>
> }
>
> void set_exception(boost::exception_ptr p)
> {
> lazy_init();
> boost::unique_lock<boost::mutex> lock(future_->mutex);
> if(future_->done)
> {
> boost::throw_exception(promise_already_satisfied());
> }
> future_->mark_exceptional_finish_internal(p, lock);
> }
>
>
> void set_value_at_thread_exit(const R& r)
> {
> if (future_.get()==0)
> {
> boost::throw_exception(promise_moved());
> }
> future_->set_value_at_thread_exit(r);
> }
>
> void set_value_at_thread_exit(R && r)
> {
> if (future_.get()==0)
> {
> boost::throw_exception(promise_moved());
> }
> future_->set_value_at_thread_exit(boost::move(r));
> }
> void set_exception_at_thread_exit(exception_ptr e)
> {
> if (future_.get()==0)
> {
> boost::throw_exception(promise_moved());
> }
> future_->set_exception_at_thread_exit(e);
> }
>
> template<typename F>
> void set_wait_callback(F f)
> {
> lazy_init();
> future_->set_wait_callback(f,this);
> }
>
> };
>
> template <typename R>
> class promise<R&>
> {
> typedef boost::shared_ptr<detail::future_object<R&> > future_ptr;
>
> future_ptr future_;
> bool future_obtained;
>
> void lazy_init()
> {
>
># 1 "/usr/include/boost/detail/atomic_undef_macros.hpp" 1 3 4
># 1881 "/usr/include/boost/thread/future.hpp" 2 3 4
> if(!atomic_load(&future_))
> {
> future_ptr blank;
> atomic_compare_exchange(&future_,&blank,future_ptr(new detail::future_object<R&>));
> }
># 1 "/usr/include/boost/detail/atomic_redef_macros.hpp" 1 3 4
># 1887 "/usr/include/boost/thread/future.hpp" 2 3 4
>
> }
>
> public:
> promise(promise const&) = delete; promise& operator=(promise const&) = delete;
># 1904 "/usr/include/boost/thread/future.hpp" 3 4
> promise():
>
> future_(),
>
>
>
> future_obtained(false)
> {}
>
> ~promise()
> {
> if(future_)
> {
> boost::unique_lock<boost::mutex> lock(future_->mutex);
>
> if(!future_->done && !future_->is_constructed)
> {
> future_->mark_exceptional_finish_internal(boost::copy_exception(broken_promise()), lock);
> }
> }
> }
>
>
> promise(promise && rhs) noexcept :
> future_(rhs.future_),future_obtained(rhs.future_obtained)
> {
> rhs.future_.reset();
> rhs.future_obtained=false;
> }
> promise & operator=(promise && rhs) noexcept
> {
> future_=rhs.future_;
> future_obtained=rhs.future_obtained;
> rhs.future_.reset();
> rhs.future_obtained=false;
> return *this;
> }
>
> void swap(promise& other)
> {
> future_.swap(other.future_);
> std::swap(future_obtained,other.future_obtained);
> }
>
>
> unique_future<R&> get_future()
> {
> lazy_init();
> if (future_.get()==0)
> {
> boost::throw_exception(promise_moved());
> }
> if (future_obtained)
> {
> boost::throw_exception(future_already_retrieved());
> }
> future_obtained=true;
> return unique_future<R&>(future_);
> }
>
> void set_value(R& r)
> {
> lazy_init();
> boost::unique_lock<boost::mutex> lock(future_->mutex);
> if(future_->done)
> {
> boost::throw_exception(promise_already_satisfied());
> }
> future_->mark_finished_with_result_internal(r, lock);
> }
>
> void set_exception(boost::exception_ptr p)
> {
> lazy_init();
> boost::unique_lock<boost::mutex> lock(future_->mutex);
> if(future_->done)
> {
> boost::throw_exception(promise_already_satisfied());
> }
> future_->mark_exceptional_finish_internal(p, lock);
> }
>
>
> void set_value_at_thread_exit(R& r)
> {
> if (future_.get()==0)
> {
> boost::throw_exception(promise_moved());
> }
> future_->set_value_at_thread_exit(r);
> }
>
> void set_exception_at_thread_exit(exception_ptr e)
> {
> if (future_.get()==0)
> {
> boost::throw_exception(promise_moved());
> }
> future_->set_exception_at_thread_exit(e);
> }
>
> template<typename F>
> void set_wait_callback(F f)
> {
> lazy_init();
> future_->set_wait_callback(f,this);
> }
>
> };
> template <>
> class promise<void>
> {
> typedef boost::shared_ptr<detail::future_object<void> > future_ptr;
>
> future_ptr future_;
> bool future_obtained;
>
> void lazy_init()
> {
>
> if(!atomic_load(&future_))
> {
> future_ptr blank;
> atomic_compare_exchange(&future_,&blank,future_ptr(new detail::future_object<void>));
> }
>
> }
> public:
> promise(promise const&) = delete; promise& operator=(promise const&) = delete;
># 2046 "/usr/include/boost/thread/future.hpp" 3 4
> promise():
>
> future_(),
>
>
>
> future_obtained(false)
> {}
>
> ~promise()
> {
> if(future_)
> {
> boost::unique_lock<boost::mutex> lock(future_->mutex);
>
> if(!future_->done && !future_->is_constructed)
> {
> future_->mark_exceptional_finish_internal(boost::copy_exception(broken_promise()), lock);
> }
> }
> }
>
>
> promise(promise && rhs) noexcept :
> future_(rhs.future_),future_obtained(rhs.future_obtained)
> {
>
> rhs.future_.reset();
> rhs.future_obtained=false;
> }
>
> promise & operator=(promise && rhs) noexcept
> {
> future_=rhs.future_;
> future_obtained=rhs.future_obtained;
> rhs.future_.reset();
> rhs.future_obtained=false;
> return *this;
> }
>
> void swap(promise& other)
> {
> future_.swap(other.future_);
> std::swap(future_obtained,other.future_obtained);
> }
>
>
> unique_future<void> get_future()
> {
> lazy_init();
>
> if (future_.get()==0)
> {
> boost::throw_exception(promise_moved());
> }
> if(future_obtained)
> {
> boost::throw_exception(future_already_retrieved());
> }
> future_obtained=true;
> return unique_future<void>(future_);
> }
>
> void set_value()
> {
> lazy_init();
> boost::unique_lock<boost::mutex> lock(future_->mutex);
> if(future_->done)
> {
> boost::throw_exception(promise_already_satisfied());
> }
> future_->mark_finished_with_result_internal(lock);
> }
>
> void set_exception(boost::exception_ptr p)
> {
> lazy_init();
> boost::unique_lock<boost::mutex> lock(future_->mutex);
> if(future_->done)
> {
> boost::throw_exception(promise_already_satisfied());
> }
> future_->mark_exceptional_finish_internal(p,lock);
> }
>
>
> void set_value_at_thread_exit()
> {
> if (future_.get()==0)
> {
> boost::throw_exception(promise_moved());
> }
> future_->set_value_at_thread_exit();
> }
>
> void set_exception_at_thread_exit(exception_ptr e)
> {
> if (future_.get()==0)
> {
> boost::throw_exception(promise_moved());
> }
> future_->set_exception_at_thread_exit(e);
> }
>
> template<typename F>
> void set_wait_callback(F f)
> {
> lazy_init();
> future_->set_wait_callback(f,this);
> }
>
> };
># 2169 "/usr/include/boost/thread/future.hpp" 3 4
> namespace detail { template <typename T> struct enable_move_utility_emulation_dummy_specialization< promise<T> > : integral_constant<bool, false> {}; }
>
> namespace detail
> {
># 2184 "/usr/include/boost/thread/future.hpp" 3 4
> template<typename R>
> struct task_base:
>
> detail::future_object<R>
> {
> bool started;
>
> task_base():
> started(false)
> {}
>
> void reset()
> {
> started=false;
> }
>
>
>
>
> virtual void do_run()=0;
> void run()
>
> {
> {
> boost::lock_guard<boost::mutex> lk(this->mutex);
> if(started)
> {
> boost::throw_exception(task_already_started());
> }
> started=true;
> }
>
>
>
> do_run();
>
> }
>
>
>
>
>
> virtual void do_apply()=0;
> void apply()
>
> {
> {
> boost::lock_guard<boost::mutex> lk(this->mutex);
> if(started)
> {
> boost::throw_exception(task_already_started());
> }
> started=true;
> }
>
>
>
> do_apply();
>
> }
>
> void owner_destroyed()
> {
> boost::unique_lock<boost::mutex> lk(this->mutex);
> if(!started)
> {
> started=true;
> this->mark_exceptional_finish_internal(boost::copy_exception(boost::broken_promise()), lk);
> }
> }
>
> };
># 2270 "/usr/include/boost/thread/future.hpp" 3 4
> template<typename F, typename R>
> struct task_object:
> task_base<R>
>
> {
> private:
> task_object(task_object&);
> public:
> F f;
> task_object(F const& f_):
> f(f_)
> {}
> task_object(F && f_):
> f(boost::move(f_))
> {}
># 2294 "/usr/include/boost/thread/future.hpp" 3 4
> void do_apply()
> {
> try
> {
> this->set_value_at_thread_exit(f());
> }
>
>
> catch(thread_interrupted& )
> {
> this->set_interrupted_at_thread_exit();
> }
>
> catch(...)
> {
> this->set_exception_at_thread_exit(current_exception());
> }
> }
># 2321 "/usr/include/boost/thread/future.hpp" 3 4
> void do_run()
> {
> try
> {
>
> R res((f()));
> this->mark_finished_with_result(boost::move(res));
>
>
>
> }
>
>
> catch(thread_interrupted& )
> {
> this->mark_interrupted_finish();
> }
>
> catch(...)
> {
> this->mark_exceptional_finish();
> }
> }
> };
># 2357 "/usr/include/boost/thread/future.hpp" 3 4
> template<typename F, typename R>
> struct task_object<F,R&>:
> task_base<R&>
>
> {
> private:
> task_object(task_object&);
> public:
> F f;
> task_object(F const& f_):
> f(f_)
> {}
> task_object(F && f_):
> f(boost::move(f_))
> {}
># 2381 "/usr/include/boost/thread/future.hpp" 3 4
> void do_apply()
> {
> try
> {
> this->set_value_at_thread_exit(f());
> }
>
>
> catch(thread_interrupted& )
> {
> this->set_interrupted_at_thread_exit();
> }
>
> catch(...)
> {
> this->set_exception_at_thread_exit(current_exception());
> }
> }
># 2408 "/usr/include/boost/thread/future.hpp" 3 4
> void do_run()
> {
> try
> {
> R& res((f()));
> this->mark_finished_with_result(res);
> }
>
>
> catch(thread_interrupted& )
> {
> this->mark_interrupted_finish();
> }
>
> catch(...)
> {
> this->mark_exceptional_finish();
> }
> }
> };
># 2442 "/usr/include/boost/thread/future.hpp" 3 4
> template<typename R>
> struct task_object<R (*)(), R> :
> task_base<R>
>
> {
> private:
> task_object(task_object&);
> public:
> R (*f)();
> task_object(R (*f_)()):
> f(f_)
> {}
># 2464 "/usr/include/boost/thread/future.hpp" 3 4
> void do_apply()
> {
> try
> {
> R r((f()));
> this->set_value_at_thread_exit(boost::move(r));
> }
>
>
> catch(thread_interrupted& )
> {
> this->set_interrupted_at_thread_exit();
> }
>
> catch(...)
> {
> this->set_exception_at_thread_exit(current_exception());
> }
> }
># 2493 "/usr/include/boost/thread/future.hpp" 3 4
> void do_run()
> {
> try
> {
> R res((f()));
> this->mark_finished_with_result(boost::move(res));
> }
>
>
> catch(thread_interrupted& )
> {
> this->mark_interrupted_finish();
> }
>
> catch(...)
> {
> this->mark_exceptional_finish();
> }
> }
> };
># 2524 "/usr/include/boost/thread/future.hpp" 3 4
> template<typename R>
> struct task_object<R& (*)(), R&> :
> task_base<R&>
>
> {
> private:
> task_object(task_object&);
> public:
> R& (*f)();
> task_object(R& (*f_)()):
> f(f_)
> {}
># 2546 "/usr/include/boost/thread/future.hpp" 3 4
> void do_apply()
> {
> try
> {
> this->set_value_at_thread_exit(f());
> }
>
>
> catch(thread_interrupted& )
> {
> this->set_interrupted_at_thread_exit();
> }
>
> catch(...)
> {
> this->set_exception_at_thread_exit(current_exception());
> }
> }
># 2574 "/usr/include/boost/thread/future.hpp" 3 4
> void do_run()
> {
> try
> {
> this->mark_finished_with_result(f());
> }
>
>
> catch(thread_interrupted& )
> {
> this->mark_interrupted_finish();
> }
>
> catch(...)
> {
> this->mark_exceptional_finish();
> }
> }
> };
># 2605 "/usr/include/boost/thread/future.hpp" 3 4
> template<typename F>
> struct task_object<F,void>:
> task_base<void>
>
> {
> private:
> task_object(task_object&);
> public:
> F f;
> task_object(F const& f_):
> f(f_)
> {}
> task_object(F && f_):
> f(boost::move(f_))
> {}
># 2628 "/usr/include/boost/thread/future.hpp" 3 4
> void do_apply()
> {
> try
> {
> f();
>
> this->set_value_at_thread_exit();
> }
>
> catch(thread_interrupted& )
> {
> this->set_interrupted_at_thread_exit();
> }
>
> catch(...)
> {
> this->set_exception_at_thread_exit(current_exception());
> }
> }
># 2655 "/usr/include/boost/thread/future.hpp" 3 4
> void do_run()
> {
> try
> {
> f();
>
> this->mark_finished_with_result();
> }
>
> catch(thread_interrupted& )
> {
> this->mark_interrupted_finish();
> }
>
> catch(...)
> {
> this->mark_exceptional_finish();
> }
> }
> };
># 2687 "/usr/include/boost/thread/future.hpp" 3 4
> template<>
> struct task_object<void (*)(),void>:
> task_base<void>
>
> {
> private:
> task_object(task_object&);
> public:
> void (*f)();
> task_object(void (*f_)()):
> f(f_)
> {}
># 2707 "/usr/include/boost/thread/future.hpp" 3 4
> void do_apply()
> {
> try
> {
> f();
>
> this->set_value_at_thread_exit();
> }
>
> catch(thread_interrupted& )
> {
> this->set_interrupted_at_thread_exit();
> }
>
> catch(...)
> {
> this->set_exception_at_thread_exit(current_exception());
> }
> }
># 2734 "/usr/include/boost/thread/future.hpp" 3 4
> void do_run()
> {
> try
> {
> f();
>
> this->mark_finished_with_result();
> }
>
> catch(thread_interrupted& )
> {
> this->mark_interrupted_finish();
> }
>
> catch(...)
> {
> this->mark_exceptional_finish();
> }
> }
> };
>
> }
># 2773 "/usr/include/boost/thread/future.hpp" 3 4
> template<typename R>
> class packaged_task
> {
> typedef boost::shared_ptr<detail::task_base<R> > task_ptr;
> boost::shared_ptr<detail::task_base<R> > task;
>
> bool future_obtained;
> struct dummy;
>
> public:
> typedef R result_type;
> packaged_task(packaged_task const&) = delete; packaged_task& operator=(packaged_task const&) = delete;
>
> packaged_task():
> future_obtained(false)
> {}
># 2812 "/usr/include/boost/thread/future.hpp" 3 4
> explicit packaged_task(R(*f)())
> {
> typedef R(*FR)();
> typedef detail::task_object<FR,R> task_object_type;
> task= task_ptr(new task_object_type(f));
> future_obtained=false;
> }
>
>
>
> template <class F>
> explicit packaged_task(F && f
> , typename disable_if<is_same<typename decay<F>::type, packaged_task>, dummy* >::type=0
> )
> {
> typedef typename remove_cv<typename remove_reference<F>::type>::type FR;
>
>
>
>
>
>
>
> typedef detail::task_object<FR,R> task_object_type;
>
> task = task_ptr(new task_object_type(boost::forward<F>(f)));
> future_obtained = false;
>
> }
># 2972 "/usr/include/boost/thread/future.hpp" 3 4
> ~packaged_task()
> {
> if(task)
> {
> task->owner_destroyed();
> }
> }
>
>
> packaged_task(packaged_task && other) noexcept :
> future_obtained(other.future_obtained)
> {
> task.swap(other.task);
> other.future_obtained=false;
> }
> packaged_task& operator=(packaged_task && other) noexcept
> {
>
>
>
> packaged_task temp(boost::move(other));
>
>
>
> swap(temp);
> return *this;
> }
>
> void reset()
> {
> if (!valid())
> throw future_error(system::make_error_code(future_errc::no_state));
> task->reset();
> future_obtained=false;
> }
>
> void swap(packaged_task& other) noexcept
> {
> task.swap(other.task);
> std::swap(future_obtained,other.future_obtained);
> }
> bool valid() const noexcept
> {
> return task.get()!=0;
> }
>
>
> unique_future<R> get_future()
> {
>
> if(!task)
> {
> boost::throw_exception(task_moved());
> }
> else if(!future_obtained)
> {
> future_obtained=true;
> return unique_future<R>(task);
> }
> else
> {
> boost::throw_exception(future_already_retrieved());
> }
>
>
> }
># 3063 "/usr/include/boost/thread/future.hpp" 3 4
> void operator()()
> {
> if(!task)
> {
> boost::throw_exception(task_moved());
> }
> task->run();
> }
> void make_ready_at_thread_exit()
> {
> if(!task)
> {
> boost::throw_exception(task_moved());
> }
> if (task->has_value())
> boost::throw_exception(promise_already_satisfied());
> task->apply();
> }
>
> template<typename F>
> void set_wait_callback(F f)
> {
> task->set_wait_callback(f,this);
> }
>
> };
># 3099 "/usr/include/boost/thread/future.hpp" 3 4
> namespace detail { template <typename T> struct enable_move_utility_emulation_dummy_specialization< packaged_task<T> > : integral_constant<bool, false> {}; }
>
> namespace detail
> {
>
>
>
> template <class Rp, class Fp>
> unique_future<Rp>
> make_future_deferred_object(Fp && f)
> {
> shared_ptr<future_deferred_object<Rp, Fp> >
> h(new future_deferred_object<Rp, Fp>(boost::forward<Fp>(f)));
> return unique_future<Rp>(h);
> }
>
>
>
>
> template <class Rp, class Fp>
> unique_future<Rp>
> make_future_async_object(Fp && f)
> {
> shared_ptr<future_async_object<Rp, Fp> >
> h(new future_async_object<Rp, Fp>(boost::forward<Fp>(f)));
> return unique_future<Rp>(h);
> }
>
> }
># 3153 "/usr/include/boost/thread/future.hpp" 3 4
> template <class R>
> unique_future<R>
> async(launch policy, R(*f)())
> {
> typedef packaged_task<R> packaged_task_type;
>
> if (int(policy) & int(launch::async))
> {
># 3169 "/usr/include/boost/thread/future.hpp" 3 4
> packaged_task_type pt( f );
>
> unique_future<R> ret = pt.get_future();
> ret.set_async();
> boost::thread( boost::move(pt) ).detach();
> return ::boost::move(ret);
>
> }
> else if (int(policy) & int(launch::deferred))
> {
># 3187 "/usr/include/boost/thread/future.hpp" 3 4
> std::terminate();
> unique_future<R> ret;
> return ::boost::move(ret);
>
>
> } else {
> std::terminate();
> unique_future<R> ret;
> return ::boost::move(ret);
> }
> }
># 3228 "/usr/include/boost/thread/future.hpp" 3 4
> template <class F>
> unique_future<typename boost::result_of<typename decay<F>::type()>::type>
> async(launch policy, F && f)
> {
> typedef typename boost::result_of<typename decay<F>::type()>::type R;
> typedef packaged_task<R> packaged_task_type;
>
>
>
> if (int(policy) & int(launch::async))
> {
># 3247 "/usr/include/boost/thread/future.hpp" 3 4
> packaged_task_type pt( boost::forward<F>(f) );
>
> unique_future<R> ret = pt.get_future();
> ret.set_async();
>
>
>
> boost::thread( boost::move(pt) ).detach();
>
> return ::boost::move(ret);
>
> }
> else if (int(policy) & int(launch::deferred))
> {
># 3269 "/usr/include/boost/thread/future.hpp" 3 4
> std::terminate();
> unique_future<R> ret;
> return ::boost::move(ret);
>
>
>
>
>
>
>
> } else {
> std::terminate();
> unique_future<R> ret;
> return ::boost::move(ret);
> }
> }
># 3301 "/usr/include/boost/thread/future.hpp" 3 4
> template <class R>
> unique_future<R>
> async(R(*f)())
> {
> return async(launch(launch::any), f);
> }
># 3320 "/usr/include/boost/thread/future.hpp" 3 4
> template <class F>
> unique_future<typename boost::result_of<F()>::type>
> async(F && f)
> {
> return async(launch(launch::any), boost::forward<F>(f));
> }
>
>
>
>
>
>
> template <typename T>
> unique_future<typename decay<T>::type> make_future(T && value)
> {
> typedef typename decay<T>::type future_type;
> promise<future_type> p;
> p.set_value(boost::forward<T>(value));
> return p.get_future();
> }
># 3353 "/usr/include/boost/thread/future.hpp" 3 4
> template <typename T>
> unique_future<typename decay<T>::type> make_ready_future(T && value)
> {
> typedef typename decay<T>::type future_type;
> promise<future_type> p;
> p.set_value(boost::forward<T>(value));
> return p.get_future();
> }
># 3374 "/usr/include/boost/thread/future.hpp" 3 4
> template <typename T>
> unique_future<T> make_exceptional_future(exception_ptr ex)
> {
> promise<T> p;
> p.set_exception(ex);
> return p.get_future();
> }
># 3402 "/usr/include/boost/thread/future.hpp" 3 4
> template <typename T>
> shared_future<typename decay<T>::type> make_shared_future(T && value)
> {
> typedef typename decay<T>::type future_type;
> promise<future_type> p;
> p.set_value(boost::forward<T>(value));
> return p.get_future().share();
> }
>
>
> inline shared_future<void> make_shared_future()
> {
> promise<void> p;
> return p.get_future().share();
>
> }
>
>
>
>
> template <typename T>
> shared_future<typename decay<T>::type> make_ready_shared_future(T && value)
> {
> typedef typename decay<T>::type future_type;
> promise<future_type> p;
> p.set_value(boost::forward<T>(value));
> return p.get_future().share();
> }
>
>
> inline shared_future<void> make_ready_shared_future()
> {
> promise<void> p;
> return p.get_future().share();
>
> }
>
>
>
>
> template <typename T>
> shared_future<T> make_exceptional_shared_future(exception_ptr ex)
> {
> promise<T> p;
> p.set_exception(ex);
> return p.get_future().share();
> }
># 3927 "/usr/include/boost/thread/future.hpp" 3 4
>}
># 25 "/usr/include/boost/thread.hpp" 2 3 4
># 20 "../src/io.h" 2
># 1 "/usr/include/c++/4.8.2/queue" 1 3
># 58 "/usr/include/c++/4.8.2/queue" 3
> 
># 59 "/usr/include/c++/4.8.2/queue" 3
>
>
>
>
>
># 1 "/usr/include/c++/4.8.2/bits/stl_queue.h" 1 3
># 62 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 92 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
> template<typename _Tp, typename _Sequence = deque<_Tp> >
> class queue
> {
>
> typedef typename _Sequence::value_type _Sequence_value_type;
> 
> 
> 
> 
>
> template<typename _Tp1, typename _Seq1>
> friend bool
> operator==(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);
>
> template<typename _Tp1, typename _Seq1>
> friend bool
> operator<(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);
>
> public:
> typedef typename _Sequence::value_type value_type;
> typedef typename _Sequence::reference reference;
> typedef typename _Sequence::const_reference const_reference;
> typedef typename _Sequence::size_type size_type;
> typedef _Sequence container_type;
>
> protected:
># 126 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
> _Sequence c;
>
> public:
># 137 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
> explicit
> queue(const _Sequence& __c)
> : c(__c) { }
>
> explicit
> queue(_Sequence&& __c = _Sequence())
> : c(std::move(__c)) { }
>
>
>
>
>
> bool
> empty() const
> { return c.empty(); }
>
>
> size_type
> size() const
> { return c.size(); }
>
>
>
>
>
> reference
> front()
> {
> ;
> return c.front();
> }
>
>
>
>
>
> const_reference
> front() const
> {
> ;
> return c.front();
> }
>
>
>
>
>
> reference
> back()
> {
> ;
> return c.back();
> }
>
>
>
>
>
> const_reference
> back() const
> {
> ;
> return c.back();
> }
># 211 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
> void
> push(const value_type& __x)
> { c.push_back(__x); }
>
>
> void
> push(value_type&& __x)
> { c.push_back(std::move(__x)); }
>
> template<typename... _Args>
> void
> emplace(_Args&&... __args)
> { c.emplace_back(std::forward<_Args>(__args)...); }
># 237 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
> void
> pop()
> {
> ;
> c.pop_front();
> }
>
>
> void
> swap(queue& __q)
> noexcept(noexcept(swap(c, __q.c)))
> {
> using std::swap;
> swap(c, __q.c);
> }
>
> };
># 266 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
> template<typename _Tp, typename _Seq>
> inline bool
> operator==(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
> { return __x.c == __y.c; }
># 284 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
> template<typename _Tp, typename _Seq>
> inline bool
> operator<(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
> { return __x.c < __y.c; }
>
>
> template<typename _Tp, typename _Seq>
> inline bool
> operator!=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Tp, typename _Seq>
> inline bool
> operator>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
> { return __y < __x; }
>
>
> template<typename _Tp, typename _Seq>
> inline bool
> operator<=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Tp, typename _Seq>
> inline bool
> operator>=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Tp, typename _Seq>
> inline void
> swap(queue<_Tp, _Seq>& __x, queue<_Tp, _Seq>& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
>
> template<typename _Tp, typename _Seq, typename _Alloc>
> struct uses_allocator<queue<_Tp, _Seq>, _Alloc>
> : public uses_allocator<_Seq, _Alloc>::type { };
># 365 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
> template<typename _Tp, typename _Sequence = vector<_Tp>,
> typename _Compare = less<typename _Sequence::value_type> >
> class priority_queue
> {
>
> typedef typename _Sequence::value_type _Sequence_value_type;
> 
> 
> 
> 
> 
>
>
> public:
> typedef typename _Sequence::value_type value_type;
> typedef typename _Sequence::reference reference;
> typedef typename _Sequence::const_reference const_reference;
> typedef typename _Sequence::size_type size_type;
> typedef _Sequence container_type;
>
> protected:
>
> _Sequence c;
> _Compare comp;
>
> public:
># 401 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
> explicit
> priority_queue(const _Compare& __x,
> const _Sequence& __s)
> : c(__s), comp(__x)
> { std::make_heap(c.begin(), c.end(), comp); }
>
> explicit
> priority_queue(const _Compare& __x = _Compare(),
> _Sequence&& __s = _Sequence())
> : c(std::move(__s)), comp(__x)
> { std::make_heap(c.begin(), c.end(), comp); }
># 441 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
> template<typename _InputIterator>
> priority_queue(_InputIterator __first, _InputIterator __last,
> const _Compare& __x,
> const _Sequence& __s)
> : c(__s), comp(__x)
> {
> ;
> c.insert(c.end(), __first, __last);
> std::make_heap(c.begin(), c.end(), comp);
> }
>
> template<typename _InputIterator>
> priority_queue(_InputIterator __first, _InputIterator __last,
> const _Compare& __x = _Compare(),
> _Sequence&& __s = _Sequence())
> : c(std::move(__s)), comp(__x)
> {
> ;
> c.insert(c.end(), __first, __last);
> std::make_heap(c.begin(), c.end(), comp);
> }
>
>
>
>
>
> bool
> empty() const
> { return c.empty(); }
>
>
> size_type
> size() const
> { return c.size(); }
>
>
>
>
>
> const_reference
> top() const
> {
> ;
> return c.front();
> }
># 495 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
> void
> push(const value_type& __x)
> {
> c.push_back(__x);
> std::push_heap(c.begin(), c.end(), comp);
> }
>
>
> void
> push(value_type&& __x)
> {
> c.push_back(std::move(__x));
> std::push_heap(c.begin(), c.end(), comp);
> }
>
> template<typename... _Args>
> void
> emplace(_Args&&... __args)
> {
> c.emplace_back(std::forward<_Args>(__args)...);
> std::push_heap(c.begin(), c.end(), comp);
> }
># 530 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
> void
> pop()
> {
> ;
> std::pop_heap(c.begin(), c.end(), comp);
> c.pop_back();
> }
>
>
> void
> swap(priority_queue& __pq)
> noexcept(noexcept(swap(c, __pq.c)) && noexcept(swap(comp, __pq.comp)))
> {
> using std::swap;
> swap(c, __pq.c);
> swap(comp, __pq.comp);
> }
>
> };
>
>
>
>
> template<typename _Tp, typename _Sequence, typename _Compare>
> inline void
> swap(priority_queue<_Tp, _Sequence, _Compare>& __x,
> priority_queue<_Tp, _Sequence, _Compare>& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
>
> template<typename _Tp, typename _Sequence, typename _Compare,
> typename _Alloc>
> struct uses_allocator<priority_queue<_Tp, _Sequence, _Compare>, _Alloc>
> : public uses_allocator<_Sequence, _Alloc>::type { };
>
>
>
>}
># 65 "/usr/include/c++/4.8.2/queue" 2 3
># 21 "../src/io.h" 2
>
>
>
>
>typedef std::pair<std::basic_ostream<char> **, std::string> scommand;
>
>
>
>const unsigned short TCPport1 = 10023;
>const unsigned short TCPport2 = 10024;
># 39 "../src/io.h"
>class inputLocalServer
>{
>public:
>
> boost::mutex *commandQueueMutex;
> std::queue<scommand> *commands;
>
> inputLocalServer(boost::mutex *m, std::queue<scommand> *c):commandQueueMutex(m), commands(c) {};
>
> void operator () ();
>};
>
>
>
>extern std::basic_ostream<char> *remoteStream1;
>extern std::basic_ostream<char> *remoteStream2;
># 63 "../src/io.h"
>class inputSocketServer
>{
>public:
>
> boost::mutex *commandQueueMutex;
> std::queue<scommand> *commands;
>
> inputSocketServer(boost::mutex *m, std::queue<scommand> *c):commandQueueMutex(m), commands(c) {};
>
> void operator () ();
>
>};
>
>
>
>
>
>
>class watchdogDriver
>{
>public:
>
> boost::mutex *accessMutex;
> uint32_t *value;
>
> watchdogDriver(boost::mutex *m, uint32_t *v):accessMutex(m), value(v)
> {
> fd = open("/dev/watchdog", 01);
> };
>
> void operator () ();
>
>private:
>
> int fd;
>
>};
>
>
>
>
>
>class interfaceSystem
>{
>public:
> void sendInitialDetectionMessage(pointData &pd, std::string *time);
> void sendStrongDetectionMessage(pointData &pd, std::string *time);
> void sendTargetDetectionMessage(target *t);
>};
>
>
>
>void showStartup(wildfireStatus &stats);
>
>extern std::string passwordString;
># 21 "../src/wildfire.cpp" 2
>
># 1 "../src/history.h" 1
># 17 "../src/history.h"
># 1 "/usr/include/c++/4.8.2/cstring" 1 3
># 39 "/usr/include/c++/4.8.2/cstring" 3
> 
># 40 "/usr/include/c++/4.8.2/cstring" 3
># 18 "../src/history.h" 2
>
># 1 "/usr/include/c++/4.8.2/cstdlib" 1 3
># 39 "/usr/include/c++/4.8.2/cstdlib" 3
> 
># 40 "/usr/include/c++/4.8.2/cstdlib" 3
># 20 "../src/history.h" 2
># 30 "../src/history.h"
>typedef std::map<targetID_t, target *> targetMap;
>typedef std::list<targetID_t> IDlist;
>typedef std::list<target *> targetList;
>typedef std::list<position> posList;
>typedef std::list<std::string> stringList;
>
>namespace history
>{
>
> const char *const historyBackingStoreName = "/wildfireData/history.iwh";
> const char *const dataFolder = "/wildfireData/";
> const char *const backingStoreHeader = "iWildFire target history file version: ";
>
> const double currentFileVersion = 1.0;
> const uint32_t maxLineLength = 1024;
>
>
>
> const uint32_t minTargetCount = 100;
># 57 "../src/history.h"
> class targetHistory
> {
> typedef std::map<targetID_t, target *>::iterator iterator;
> private:
> targetMap targets;
> targetMap annulledTargets;
> posList annulledPositions;
> IDlist IDs;
> std::fstream backingStore;
> uint32_t lastID;
> bool checkData();
>
> public:
> targetHistory();
> targetID_t targetExists(targetData *data);
> uint32_t addTarget(targetData *data);
> bool updateTarget(targetID_t t, targetData *data);
> bool acknowledgeTarget(targetID_t t);
> bool writeHistoryToFile();
> bool addTargetToFile(target *t);
> bool forgetTarget(targetID_t t);
> bool forgetOldTargets(time_t timeDelta);
> bool restoreTarget(targetID_t t);
> IDlist *getAllTargets(void);
> IDlist *getActiveTargets(void);
> target *getTarget(targetID_t t);
> targetList *getAllTargetDetails(void);
> bool ignoreTarget(targetID_t t, uint32_t time, double sizeChange = 0, double densityChange = 0);
> bool annulTarget(targetID_t t, std::string &message);
> void updateAll(void);
> bool reduceFileSystemUse(bool serious);
> bool readBackingStore();
> stringList *getFilesFromTarget(targetID_t id, position pos, time_t time);
> void clear(bool dataFileToo);
> bool deleteTarget(targetID_t t);
> posList *getAnnulledPositions(void);
> dataFileList *getAllReferencedDataFiles(void);
> };
>}
># 23 "../src/wildfire.cpp" 2
>
>
>
># 1 "/usr/include/boost/foreach.hpp" 1 3 4
># 27 "/usr/include/boost/foreach.hpp" 3 4
># 1 "/usr/include/c++/4.8.2/cstddef" 1 3 4
># 39 "/usr/include/c++/4.8.2/cstddef" 3 4
> 
># 40 "/usr/include/c++/4.8.2/cstddef" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
># 42 "/usr/include/c++/4.8.2/cstddef" 2 3
># 28 "/usr/include/boost/foreach.hpp" 2 3 4
># 98 "/usr/include/boost/foreach.hpp" 3 4
>namespace boost
>{
>
>
>template<typename T>
>class iterator_range;
>
>
>template<typename T>
>class sub_range;
>
>namespace foreach
>{
>
>
>
> template<typename T>
> inline std::pair<T, T> in_range(T begin, T end)
> {
> return std::make_pair(begin, end);
> }
>
>
>
>
>
> template<typename T>
> struct is_lightweight_proxy
> : boost::mpl::false_
> {
> };
>
>
>
>
>
> template<typename T>
> struct is_noncopyable
>
> : boost::mpl::or_<
> boost::is_abstract<T>
> , boost::is_base_and_derived<boost::noncopyable, T>
> >
>
>
>
>
>
>
>
> {
> };
>
>}
>
>}
># 167 "/usr/include/boost/foreach.hpp" 3 4
>template<typename T>
>inline boost::foreach::is_lightweight_proxy<T> *
>boost_foreach_is_lightweight_proxy(T *&, boost::foreach::tag) { return 0; }
>
>template<typename T>
>inline boost::mpl::true_ *
>boost_foreach_is_lightweight_proxy(std::pair<T, T> *&, boost::foreach::tag) { return 0; }
>
>template<typename T>
>inline boost::mpl::true_ *
>boost_foreach_is_lightweight_proxy(boost::iterator_range<T> *&, boost::foreach::tag) { return 0; }
>
>template<typename T>
>inline boost::mpl::true_ *
>boost_foreach_is_lightweight_proxy(boost::sub_range<T> *&, boost::foreach::tag) { return 0; }
>
>template<typename T>
>inline boost::mpl::true_ *
>boost_foreach_is_lightweight_proxy(T **&, boost::foreach::tag) { return 0; }
>
>
>
>
>
>
>template<typename T>
>inline boost::foreach::is_noncopyable<T> *
>boost_foreach_is_noncopyable(T *&, boost::foreach::tag) { return 0; }
>
>namespace boost
>{
>
>namespace foreach_detail_
>{
>
>
>
>
>template<typename Bool1, typename Bool2>
>inline boost::mpl::and_<Bool1, Bool2> *and_(Bool1 *, Bool2 *) { return 0; }
>
>template<typename Bool1, typename Bool2, typename Bool3>
>inline boost::mpl::and_<Bool1, Bool2, Bool3> *and_(Bool1 *, Bool2 *, Bool3 *) { return 0; }
>
>template<typename Bool1, typename Bool2>
>inline boost::mpl::or_<Bool1, Bool2> *or_(Bool1 *, Bool2 *) { return 0; }
>
>template<typename Bool1, typename Bool2, typename Bool3>
>inline boost::mpl::or_<Bool1, Bool2, Bool3> *or_(Bool1 *, Bool2 *, Bool3 *) { return 0; }
>
>template<typename Bool1>
>inline boost::mpl::not_<Bool1> *not_(Bool1 *) { return 0; }
>
>template<typename T>
>inline boost::is_array<T> *is_array_(T const &) { return 0; }
>
>template<typename T>
>inline boost::is_const<T> *is_const_(T &) { return 0; }
>
>
>template<typename T>
>inline boost::mpl::true_ *is_const_(T const &) { return 0; }
># 238 "/usr/include/boost/foreach.hpp" 3 4
>template<typename T>
>inline boost::is_rvalue_reference<T &&> *is_rvalue_(T &&, int) { return 0; }
>
>
>
>
>
>struct auto_any_base
>{
>
>
> operator bool() const
> {
> return false;
> }
>};
>
>template<typename T>
>struct auto_any : auto_any_base
>{
> explicit auto_any(T const &t)
> : item(t)
> {
> }
>
>
>
>
> mutable T item;
>};
>
>typedef auto_any_base const &auto_any_t;
>
>template<typename T, typename C>
>inline typename boost::mpl::if_<C, T const, T>::type &auto_any_cast(auto_any_t a)
>{
> return static_cast<auto_any<T> const &>(a).item;
>}
>
>typedef boost::mpl::true_ const_;
>
>
>
>
>template<typename T, typename C = boost::mpl::false_>
>struct type2type
> : boost::mpl::if_<C, T const, T>
>{
>};
>
>template<typename T>
>struct wrap_cstr
>{
> typedef T type;
>};
>
>template<>
>struct wrap_cstr<char *>
>{
> typedef wrap_cstr<char *> type;
> typedef char *iterator;
> typedef char *const_iterator;
>};
>
>template<>
>struct wrap_cstr<char const *>
>{
> typedef wrap_cstr<char const *> type;
> typedef char const *iterator;
> typedef char const *const_iterator;
>};
>
>template<>
>struct wrap_cstr<wchar_t *>
>{
> typedef wrap_cstr<wchar_t *> type;
> typedef wchar_t *iterator;
> typedef wchar_t *const_iterator;
>};
>
>template<>
>struct wrap_cstr<wchar_t const *>
>{
> typedef wrap_cstr<wchar_t const *> type;
> typedef wchar_t const *iterator;
> typedef wchar_t const *const_iterator;
>};
>
>template<typename T>
>struct is_char_array
> : mpl::and_<
> is_array<T>
> , mpl::or_<
> is_convertible<T, char const *>
> , is_convertible<T, wchar_t const *>
> >
> >
>{};
>
>template<typename T, typename C = boost::mpl::false_>
>struct foreach_iterator
>{
># 353 "/usr/include/boost/foreach.hpp" 3 4
> struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING; typedef struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING353 : boost::mpl::assert_ { static boost::mpl::failed ************ (IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING::************ assert_arg()) (T&) { return 0; } } mpl_assert_arg353; enum { mpl_assertion_in_line_353 = sizeof( boost::mpl::assertion_failed<((!is_char_array<T>::value))>( mpl_assert_arg353::assert_arg() ) ) };
>
>
>
>
> typedef typename wrap_cstr<T>::type container;
>
> typedef typename boost::mpl::eval_if<
> C
> , range_const_iterator<container>
> , range_mutable_iterator<container>
> >::type type;
>};
>
>
>template<typename T, typename C = boost::mpl::false_>
>struct foreach_reverse_iterator
>{
># 384 "/usr/include/boost/foreach.hpp" 3 4
> struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING; typedef struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING384 : boost::mpl::assert_ { static boost::mpl::failed ************ (IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING::************ assert_arg()) (T&) { return 0; } } mpl_assert_arg384; enum { mpl_assertion_in_line_384 = sizeof( boost::mpl::assertion_failed<((!is_char_array<T>::value))>( mpl_assert_arg384::assert_arg() ) ) };
>
>
>
>
> typedef typename wrap_cstr<T>::type container;
>
> typedef typename boost::mpl::eval_if<
> C
> , range_reverse_iterator<container const>
> , range_reverse_iterator<container>
> >::type type;
>};
>
>template<typename T, typename C = boost::mpl::false_>
>struct foreach_reference
> : iterator_reference<typename foreach_iterator<T, C>::type>
>{
>};
>
>
>
>
>template<typename T>
>inline type2type<T> *encode_type(T &, boost::mpl::false_ *) { return 0; }
>
>template<typename T>
>inline type2type<T, const_> *encode_type(T const &, boost::mpl::true_ *) { return 0; }
>
>
>
>
>inline bool set_false(bool &b)
>{
> b = false;
> return false;
>}
>
>
>
>
>template<typename T>
>inline T *&to_ptr(T const &)
>{
> static T *t = 0;
> return t;
>}
># 630 "/usr/include/boost/foreach.hpp" 3 4
>template<typename T>
>inline auto_any<T> contain(T const &t, boost::mpl::true_ *)
>{
> return auto_any<T>(t);
>}
>
>template<typename T>
>inline auto_any<T *> contain(T &t, boost::mpl::false_ *)
>{
>
>
>
>
> return auto_any<T *>(boost::addressof(t));
>
>}
># 659 "/usr/include/boost/foreach.hpp" 3 4
>template<typename T, typename C>
>inline auto_any<typename foreach_iterator<T, C>::type>
>begin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
>{
> return auto_any<typename foreach_iterator<T, C>::type>(
> boost::begin(auto_any_cast<T, C>(col)));
>}
>
>template<typename T, typename C>
>inline auto_any<typename foreach_iterator<T, C>::type>
>begin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
>{
> typedef typename type2type<T, C>::type type;
> typedef typename foreach_iterator<T, C>::type iterator;
> return auto_any<typename foreach_iterator<T, C>::type>(
> iterator(boost::begin((*(auto_any_cast<type *, boost::mpl::false_>(col))))));
>}
># 688 "/usr/include/boost/foreach.hpp" 3 4
>template<typename T, typename C>
>inline auto_any<T *>
>begin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *)
>{
> return auto_any<T *>(auto_any_cast<T *, boost::mpl::false_>(col));
>}
>
>
>
>
>
>template<typename T, typename C>
>inline auto_any<typename foreach_iterator<T, C>::type>
>end(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
>{
> return auto_any<typename foreach_iterator<T, C>::type>(
> boost::end(auto_any_cast<T, C>(col)));
>}
>
>template<typename T, typename C>
>inline auto_any<typename foreach_iterator<T, C>::type>
>end(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
>{
> typedef typename type2type<T, C>::type type;
> typedef typename foreach_iterator<T, C>::type iterator;
> return auto_any<typename foreach_iterator<T, C>::type>(
> iterator(boost::end((*(auto_any_cast<type *, boost::mpl::false_>(col))))));
>}
># 728 "/usr/include/boost/foreach.hpp" 3 4
>template<typename T, typename C>
>inline auto_any<int>
>end(auto_any_t, type2type<T *, C> *, boost::mpl::true_ *)
>{
> return auto_any<int>(0);
>}
>
>
>
>
>
>template<typename T, typename C>
>inline bool done(auto_any_t cur, auto_any_t end, type2type<T, C> *)
>{
> typedef typename foreach_iterator<T, C>::type iter_t;
> return auto_any_cast<iter_t, boost::mpl::false_>(cur) == auto_any_cast<iter_t, boost::mpl::false_>(end);
>}
>
>
>template<typename T, typename C>
>inline bool done(auto_any_t cur, auto_any_t, type2type<T *, C> *)
>{
> return ! *auto_any_cast<T *, boost::mpl::false_>(cur);
>}
>
>
>
>
>
>template<typename T, typename C>
>inline void next(auto_any_t cur, type2type<T, C> *)
>{
> typedef typename foreach_iterator<T, C>::type iter_t;
> ++auto_any_cast<iter_t, boost::mpl::false_>(cur);
>}
>
>
>
>
>template<typename T, typename C>
>inline typename foreach_reference<T, C>::type
>deref(auto_any_t cur, type2type<T, C> *)
>{
> typedef typename foreach_iterator<T, C>::type iter_t;
> return *auto_any_cast<iter_t, boost::mpl::false_>(cur);
>}
>
>
>
>
>template<typename T, typename C>
>inline auto_any<typename foreach_reverse_iterator<T, C>::type>
>rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
>{
> return auto_any<typename foreach_reverse_iterator<T, C>::type>(
> boost::rbegin(auto_any_cast<T, C>(col)));
>}
>
>template<typename T, typename C>
>inline auto_any<typename foreach_reverse_iterator<T, C>::type>
>rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
>{
> typedef typename type2type<T, C>::type type;
> typedef typename foreach_reverse_iterator<T, C>::type iterator;
> return auto_any<typename foreach_reverse_iterator<T, C>::type>(
> iterator(boost::rbegin((*(auto_any_cast<type *, boost::mpl::false_>(col))))));
>}
># 807 "/usr/include/boost/foreach.hpp" 3 4
>template<typename T, typename C>
>inline auto_any<reverse_iterator<T *> >
>rbegin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *)
>{
> T *p = auto_any_cast<T *, boost::mpl::false_>(col);
> while(0 != *p)
> ++p;
> return auto_any<reverse_iterator<T *> >(reverse_iterator<T *>(p));
>}
>
>
>
>
>
>template<typename T, typename C>
>inline auto_any<typename foreach_reverse_iterator<T, C>::type>
>rend(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
>{
> return auto_any<typename foreach_reverse_iterator<T, C>::type>(
> boost::rend(auto_any_cast<T, C>(col)));
>}
>
>template<typename T, typename C>
>inline auto_any<typename foreach_reverse_iterator<T, C>::type>
>rend(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
>{
> typedef typename type2type<T, C>::type type;
> typedef typename foreach_reverse_iterator<T, C>::type iterator;
> return auto_any<typename foreach_reverse_iterator<T, C>::type>(
> iterator(boost::rend((*(auto_any_cast<type *, boost::mpl::false_>(col))))));
>}
># 850 "/usr/include/boost/foreach.hpp" 3 4
>template<typename T, typename C>
>inline auto_any<reverse_iterator<T *> >
>rend(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *)
>{
> return auto_any<reverse_iterator<T *> >(
> reverse_iterator<T *>(auto_any_cast<T *, boost::mpl::false_>(col)));
>}
>
>
>
>
>
>template<typename T, typename C>
>inline bool rdone(auto_any_t cur, auto_any_t end, type2type<T, C> *)
>{
> typedef typename foreach_reverse_iterator<T, C>::type iter_t;
> return auto_any_cast<iter_t, boost::mpl::false_>(cur) == auto_any_cast<iter_t, boost::mpl::false_>(end);
>}
>
>
>
>
>template<typename T, typename C>
>inline void rnext(auto_any_t cur, type2type<T, C> *)
>{
> typedef typename foreach_reverse_iterator<T, C>::type iter_t;
> ++auto_any_cast<iter_t, boost::mpl::false_>(cur);
>}
>
>
>
>
>template<typename T, typename C>
>inline typename foreach_reference<T, C>::type
>rderef(auto_any_t cur, type2type<T, C> *)
>{
> typedef typename foreach_reverse_iterator<T, C>::type iter_t;
> return *auto_any_cast<iter_t, boost::mpl::false_>(cur);
>}
>
>}
>}
># 27 "../src/wildfire.cpp" 2
>
>using namespace iwf;
>
>
>
>std::string *getTimeStamp()
>{
>
> time_t rawtime;
> struct tm *timeinfo;
> char buffer[80];
>
> time(&rawtime );
> timeinfo = localtime(&rawtime);
>
> strftime(buffer, 80, "%d%b%Y_%H_%M_%S", timeinfo);
> std::string *result = new std::string(buffer);
> return result;
>}
>
>
>
>#pragma GCC optimize(0)
>
>int main(int argc, const char *argv[])
>{
>
> std::cout << wildfireString << std::endl << wildfireVerString << std::endl;
>
>
> boost::mutex commandQueueMutex;
># 67 "../src/wildfire.cpp"
> std::queue<scommand> commands;
>
> inputLocalServer inputLocal(&commandQueueMutex, &commands);
> boost::thread inputLocalThread(inputLocal);
>
> inputSocketServer inputSocket1(&commandQueueMutex, &commands);
> inputSocketServer inputSocket2(&commandQueueMutex, &commands);
> boost::thread inputSocketThread1(inputSocket1);
> boost::thread inputSocketThread2(inputSocket2);
>
>
> try
> {
>
>
>
> wildfireStatus stats;
>
>
>
> iWCCclass iWCC(stats);
> interfaceSystem interface;
> positioner positioning(&iWCC, stats.tHistory, &interface);
>
>
>
> measurementSettings tempSettings(stats.startRepeats, stats.singleCodeSamples, stats.singleCodeFilteredSamples,
> stats.debugLevel, defMaxScanTime, stats.detectionRatio, stats.alarmRatio, stats.codeRate, detectorChannel, stats.filters,
> stats.initialPowerLevel, stats.initialGain, stats.initialBandwidth);
> tempSettings.status = scanning;
> tempSettings.setClasses(0, &positioning, &iWCC);
>
>
>
> commandList *listOfCommands = parseCommandLine(argc, argv);
> processCommands(0, stats, tempSettings, listOfCommands);
> delete(listOfCommands);
> listOfCommands = 0;
> if ((!stats.noFirmwareCheck) and ((iWCC.getStatus()[0] & 0xFFFF) < minIwccRevision))
> {
> std::cout << badFirmwareRevString1 << minIwccRevision << badFirmwareRevString2 << (iWCC.getStatus()[0] & 0xFFFF) << std::endl;
> std::string fileName, command("update iwcc ");
> std::cout << needDumpfileString1 << std::endl;
> std::cout << needDumpfileString2 << std::endl;
> std::cin >> fileName;
> command += fileName;
> const tchar **argVector;
> uint32_t argCount = tokenizeCommand(command, argVector);
> commandList *listOfCommands = parseCommands(argCount, argVector);
> std::basic_ostream<char> *stream = &(std::cout);
> processCommands(&stream, stats, tempSettings, listOfCommands);
> delete listOfCommands;
> throw e_shutdown;
> }
>
>
>
> stats.reset();
> stats.recalc();
>
>
>
>
>
>
>
> if (positioning.getPointCount() == 0)
> {
> positioning.initialisePoints(stats.startPosition, stats.stopPosition, stats.stepSize);
> }
>
>
>
> correlate *correlation = 0;
> double *rawData = new double[stats.singleCodeSamples];
>
>
>
>
>
>
>
> iWCC.setReceiverFeedback(stats.feedbackLow);
> iWCC.setReceiverGain(stats.initialGain);
> iWCC.setTransmitterPower(stats.initialPowerLevel);
> if ((!stats.noFirmwareCheck) and (iWCC.setCode(stats.codeLength, stats.origOversampleRate, stats.sampleRate, stats.code) != 0))
> {
> iWCC.reset(stats);
> iWCC.setPosition(positioning.getPosition().horizontal, positioning.getPosition().vertical);
> if (iWCC.setCode(stats.codeLength, stats.origOversampleRate, stats.sampleRate, stats.code) != 0)
> {
> throw error(setCodeFailed);
> }
> }
>
>
>
>
> measurementSettings msettings(stats.startRepeats, stats.singleCodeSamples, stats.singleCodeFilteredSamples,
> stats.debugLevel, defMaxScanTime, stats.detectionRatio, stats.alarmRatio, stats.codeRate, detectorChannel, stats.filters,
> stats.initialPowerLevel, stats.initialGain, stats.initialBandwidth);
>
>
>
> msettings.setClasses(correlation, &positioning, &iWCC);
> initialiseSignalProcessing(stats, msettings);
> msettings.rawData = rawData;;
> msettings.status = tempSettings.status;
>
>
>
> setupPoints(stats, msettings);
> showStartup(stats);
>
> volatile bool commandsAvailable1 = false;
> commandQueueMutex.lock();
> commandsAvailable1 = !commands.empty();
> commandQueueMutex.unlock();
> while (commandsAvailable1)
> {
> std::string command;
> commandQueueMutex.lock();
> std::basic_ostream<char> **stream = commands.front().first;
> command = commands.front().second;
> commands.pop();
> commandQueueMutex.unlock();
> const tchar **argVector;
> uint32_t argCount = tokenizeCommand(command, argVector);
> listOfCommands = parseCommands(argCount, argVector);
> processCommands(stream, stats, msettings, listOfCommands);
> delete listOfCommands;
> listOfCommands = 0;
> msettings.update(stats.startRepeats, stats.singleCodeSamples, stats.singleCodeFilteredSamples,
> stats.debugLevel, defMaxScanTime, stats.detectionRatio, stats.alarmRatio, stats.codeRate, detectorChannel,
> stats.filters, stats.initialPowerLevel, stats.initialGain, stats.initialBandwidth);
> commandQueueMutex.lock();
> commandsAvailable1 = !commands.empty();
> commandQueueMutex.unlock();
> }
>
>
> if (stats.testMode)
> {
> if (int result = doTests(stats, iWCC, msettings, camera) != 0)
> {
> return result;
> }
> }
> if (stats.demo)
> {
> positioning.initialisePoints(stats.startPosition, stats.stopPosition, stats.stepSize);
> for (uint32_t i = 0; i < positioning.getPointCount(); i++)
> {
> pointData pdat = positioning.getPointData(i);
> pdat.pos.vertical = 20 * sin(pdat.pos.horizontal * 4 * 3.14159 / 180);
> positioning.setPointData(i, pdat);
> }
> std::cout << "Demo mode." << std::endl;
> }
>
>
>
> if (loadState(sf::defaulSaveStateFilename, stats, msettings))
> {
> std::cout << readStateFileString << std::endl;
> float newPos, oldPos;
> std::cout << performingCalibrationString << std::endl;
> if (iWCC.doCalibrate(iWMC_m, 1, &newPos, &oldPos))
> {
> msettings.lastCalTime = time(__null);
> positioning.currentPosition = position(stats.horizSensorPosition, stats.vertSensorPosition);
> }
> }
> else
> {
> std::cout << unableToLoadStateString << std::endl;
> }
>
>
>
> positioning.goToPoint(0);
> targetData theTargetData;
>
>
>
> std::cout << readyString << std::endl;
>
> while(true)
> {
> try
> {
> iwf::wait(0.001);
> volatile bool commandsAvailable = false;
> commandQueueMutex.lock();
> commandsAvailable = !commands.empty();
> commandQueueMutex.unlock();
> while (commandsAvailable)
> {
> std::string command;
> commandQueueMutex.lock();
> std::basic_ostream<char> **stream = commands.front().first;
> command = commands.front().second;
> commands.pop();
> commandQueueMutex.unlock();
> const tchar **argVector;
> uint32_t argCount = tokenizeCommand(command, argVector);
> listOfCommands = parseCommands(argCount, argVector, false);
> if (stats.debugLevel >= 2)
> {
> if (listOfCommands->empty())
> {
> std::cout << "empty list of commands." << std::endl;
> }
> }
> processCommands(stream, stats, msettings, listOfCommands);
> delete listOfCommands;
> listOfCommands = 0;
> msettings.update(stats.startRepeats, stats.singleCodeSamples, stats.singleCodeFilteredSamples,
> stats.debugLevel, defMaxScanTime, stats.detectionRatio, stats.alarmRatio, stats.codeRate, detectorChannel,
> stats.filters, stats.initialPowerLevel, stats.initialGain, stats.initialBandwidth);
> commandQueueMutex.lock();
> commandsAvailable = !commands.empty();
> commandQueueMutex.unlock();
> }
> if (msettings.status == scanning)
> {
> if (!stats.demo)
> {
> std::stringstream gpmessage;
> position pos = positioning.getPosition();
> gpmessage << "getposition " << pos.horizontal << " " << pos.vertical << std::endl;
> if (remoteStream1 != 0)
> {
> *remoteStream1 << gpmessage.str();
> }
> if (remoteStream2 != 0)
> {
> *remoteStream2 << gpmessage.str();
> }
> if (scan(msettings))
> {
>
> uint32_t pointNumber = positioning.getPoint();
> pointData oldpd = positioning.getPointData(pointNumber);
> pointData pd = oldpd;
> double initialRatio = pd.detectedRatio;
> pd.repeats *= stats.repeatMult;
> positioning.setPointData(pointNumber, pd);
> uint32_t oldLoops = msettings.deconvolving->getLoops();
> msettings.deconvolving->setLoops(cdCheckingLoops);
> bool detected = measureOnce(msettings, &pd, true);
> msettings.deconvolving->setLoops(oldLoops);
> pd.repeats /= stats.repeatMult;
> positioning.setPointData(pointNumber, pd);
> if (pd.detectedRatio < initialRatio * 0.95)
> {
> detected = false;
> }
> if (detected)
> {
> std::string *dtime = getTimeStamp();
> std::cout << std::setw(5) << std::fixed << std::setprecision(1) << normalise360(pos.horizontal) << ", " << normalise180(pos.vertical) << ". ";
> doDetected(stats, msettings, dtime);
> interface.sendInitialDetectionMessage(pd, dtime);
> delete dtime;
> }
> }
> positioning.incrementPosition();
> }
> else
> {
> iwf::wait(0.1);
> positioning.incrementPosition();
> }
> }
> }
> catch (specials e)
> {
>
>
>
> if (e == e_commsError)
> {
> std::cout << *getTimeStamp() << std::endl;
> if (e_specialsStringSet)
> {
> std::cout << e_specialsErrorString << std::endl;
> e_specialsStringSet = false;
> }
> std::cout << "Resetting iWCC." << std::endl;
> iWCC.reset(stats);
> iwf::wait(3);
>
>
>
> iWCC.setPosition(positioning.getPosition().horizontal, positioning.getPosition().vertical);
> iWCC.setCode(stats.codeLength, stats.origOversampleRate, stats.sampleRate, stats.code);
> iWCC.setSensorPositions(stats.horizSensorPosition, stats.vertSensorPosition);
> }
> else
> {
> throw e;
> }
> }
> }
> return 0;
> }
> catch (const specials &s)
> {
> switch (s)
> {
> case(e_shutdown):
> {
> std::cout << "Shutdown: " << std::endl;
> return 0;
> }
> case(e_restart):
> {
> std::cout << "Restart: " << std::endl;
> if (e_specialsStringSet)
> {
> std::cout << e_specialsErrorString << std::endl;
> e_specialsStringSet = false;
> }
> return 1;
> }
> case(e_commsError):
> {
> std::cout << "Comms error: " << 1 << std::endl;
> return 1;
> }
> default:
> {
> std::cout << unknown_error_string << "Specials." << std::endl;
> return -1;
> }
> }
> }
> catch (char const* e)
> {
> std::cout << e << std::endl;
> return -1;
> }
> catch (const int e)
> {
> std::cout << e << std::endl;
> return e;
> }
> catch (const error_nums &e)
> {
> std::cout << "Error " << e << ": " << errors[e] << std::endl;
> return e;
> }
> catch (const error &e)
> {
> std::cout << "Error " << e.number << ": " << errors[e.number] << std::endl;
> return e.number;
> }
> catch (const errorPlus &e)
> {
> std::cout << "Error " << e.number << ": " << errors[e.number];
> std::cout << e.type;
> if (e.string != 0)
> {
> std::cout << e.string;
> }
> else
> {
> std::cout << unknown_error_string;
> }
> std::cout << std::endl;
> return e.number;
> }
> catch (...)
> {
> std::cout << unknown_error_string << std::endl;
> return -1;
> }
>}
>
>
>
>void iwf::warning(std::basic_ostream<char> *stream, error e)
>{
> if (stream != 0)
> {
> *stream << errors[e.number] << std::endl;
> }
>}
>
>
>
>void iwf::warning(std::basic_ostream<char> *stream, errorPlus e)
>{
> if (stream != 0)
> {
> *stream << errors[e.number];
> *stream << e.type;
> if (e.string != 0)
> {
> *stream << e.string;
> }
> *stream << std::endl;
> }
>}
>
>
>
>void iwf::warning(error e)
>{
> warning(&std::cout, e);
> if (remoteStream1 != 0)
> {
> warning(remoteStream1, e);
> }
> if (remoteStream2 != 0)
> {
> warning(remoteStream2, e);
> }
>}
>
>
>
>void iwf::warning(errorPlus e)
>{
> warning(&std::cout, e);
> if (remoteStream1 != 0)
> {
> warning(remoteStream1, e);
> }
> if (remoteStream2 != 0)
> {
> warning(remoteStream2, e);
> }
>}

Actions: View

Attachments on bug 1046034: 840742