[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[creduce-bugs] pass_clang_binsrch::replace-function-def-with-decl has encountered a bug
creduce 2.5.0
18e04be
Linux
cookie
4.13.0-37-generic
#42~16.04.1-Ubuntu SMP Wed Mar 7 16:03:28 UTC 2018
x86_64
***************************************************
pass_clang_binsrch::replace-function-def-with-decl has encountered a bug:
crashed: "/usr/lib/x86_64-linux-gnu/clang_delta" --transformation=replace-function-def-with-decl --counter=391 --to-counter=521 /tmp/creduce-5cnO4D/w.cpp
Please consider tarring up /home/ian/projects/debian/a-boost1.58/boost1.58-1.58.0+dfsg/creduce_bug_000
and mailing it to creduce-bugs@flux.utah.edu and we will try to fix
the bug.
This bug is not fatal, C-Reduce will continue to execute.
***************************************************
namespace std
{
typedef long unsigned int size_t;
typedef long int ptrdiff_t;
}
namespace std
{
inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
namespace __gnu_cxx
{
inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename>
class allocator;
template<>
class allocator<void>;
template<typename, typename>
struct uses_allocator;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<class _CharT>
struct char_traits;
template<> struct char_traits<char>;
template<> struct char_traits<wchar_t>;
namespace __cxx11 {
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_string;
typedef basic_string<char> string;
typedef basic_string<wchar_t> wstring;
}
}
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_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__))
__attribute__((__format__(__gnu_printf__, 1, 2)));
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__));
}
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<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<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer<unsigned __int128> { 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_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;
};
}
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>
bool
__is_null_pointer(_Type* __ptr)
;
template<typename _Type>
bool
__is_null_pointer(_Type)
;
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;
};
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
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;
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
{ };
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp>
_Tp*
__addressof(_Tp& __r)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp>
void
swap(_Tp& __a, _Tp& __b)
;
template<typename _Tp, size_t _Nm>
void
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<class _T1, class _T2>
struct pair
{
typedef _T1 first_type;
typedef _T2 second_type;
_T1 first;
_T2 second;
pair() ;
pair(const _T1& __a, const _T2& __b) ;
template<class _U1, class _U2>
pair(const pair<_U1, _U2>& __p) ;
};
template<class _T1, class _T2>
bool
operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
;
template<class _T1, class _T2>
bool
operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
;
template<class _T1, class _T2>
bool
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
;
template<class _T1, class _T2>
bool
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
;
template<class _T1, class _T2>
bool
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
;
template<class _T1, class _T2>
bool
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
;
template<class _T1, class _T2>
pair<_T1, _T2>
make_pair(_T1 __x, _T2 __y)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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 { };
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;
};
template<typename _Iterator>
struct iterator_traits
{
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 _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>
typename iterator_traits<_Iter>::iterator_category
__iterator_category(const _Iter&)
;
template<typename _Iterator, bool _HasBase>
struct _Iter_base
{
typedef _Iterator iterator_type;
static iterator_type _S_base(_Iterator __it)
;
};
template<typename _Iterator>
struct _Iter_base<_Iterator, true>
{
typedef typename _Iterator::iterator_type iterator_type;
static iterator_type _S_base(_Iterator __it)
;
};
}
namespace std
{
namespace __debug { }
}
namespace __gnu_debug
{
using namespace std::__debug;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _InputIterator>
typename iterator_traits<_InputIterator>::difference_type
__distance(_InputIterator __first, _InputIterator __last,
input_iterator_tag)
;
template<typename _RandomAccessIterator>
typename iterator_traits<_RandomAccessIterator>::difference_type
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag)
;
template<typename _InputIterator>
typename iterator_traits<_InputIterator>::difference_type
distance(_InputIterator __first, _InputIterator __last)
;
template<typename _InputIterator, typename _Distance>
void
__advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
;
template<typename _BidirectionalIterator, typename _Distance>
void
__advance(_BidirectionalIterator& __i, _Distance __n,
bidirectional_iterator_tag)
;
template<typename _RandomAccessIterator, typename _Distance>
void
__advance(_RandomAccessIterator& __i, _Distance __n,
random_access_iterator_tag)
;
template<typename _InputIterator, typename _Distance>
void
advance(_InputIterator& __i, _Distance __n)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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() ;
explicit
reverse_iterator(iterator_type __x) ;
reverse_iterator(const reverse_iterator& __x) ;
template<typename _Iter>
reverse_iterator(const reverse_iterator<_Iter>& __x) ;
iterator_type
base() const
;
reference
operator*() const
;
pointer
operator->() const
;
reverse_iterator&
operator++()
;
reverse_iterator
operator++(int)
;
reverse_iterator&
operator--()
;
reverse_iterator
operator--(int)
;
reverse_iterator
operator+(difference_type __n) const
;
reverse_iterator&
operator+=(difference_type __n)
;
reverse_iterator
operator-(difference_type __n) const
;
reverse_iterator&
operator-=(difference_type __n)
;
reference
operator[](difference_type __n) const
;
};
template<typename _Iterator>
bool
operator==(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator<(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator!=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator>(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator<=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator>=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
typename reverse_iterator<_Iterator>::difference_type
operator-(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
reverse_iterator<_Iterator>
operator+(typename reverse_iterator<_Iterator>::difference_type __n,
const reverse_iterator<_Iterator>& __x)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator==(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator<(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator!=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator>(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator<=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator>=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
typename reverse_iterator<_IteratorL>::difference_type
operator-(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
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) ;
back_insert_iterator&
operator=(typename _Container::const_reference __value)
;
back_insert_iterator&
operator*()
;
back_insert_iterator&
operator++()
;
back_insert_iterator
operator++(int)
;
};
template<typename _Container>
back_insert_iterator<_Container>
back_inserter(_Container& __x)
;
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) ;
front_insert_iterator&
operator=(typename _Container::const_reference __value)
;
front_insert_iterator&
operator*()
;
front_insert_iterator&
operator++()
;
front_insert_iterator
operator++(int)
;
};
template<typename _Container>
front_insert_iterator<_Container>
front_inserter(_Container& __x)
;
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) ;
insert_iterator&
operator=(typename _Container::const_reference __value)
;
insert_iterator&
operator*()
;
insert_iterator&
operator++()
;
insert_iterator&
operator++(int)
;
};
template<typename _Container, typename _Iterator>
insert_iterator<_Container>
inserter(_Container& __x, _Iterator __i)
;
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
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;
__normal_iterator() ;
explicit
__normal_iterator(const _Iterator& __i) ;
template<typename _Iter>
__normal_iterator(const __normal_iterator<_Iter,
typename __enable_if<
(std::__are_same<_Iter, typename _Container::pointer>::__value),
_Container>::__type>& __i) ;
reference
operator*() const
;
pointer
operator->() const
;
__normal_iterator&
operator++()
;
__normal_iterator
operator++(int)
;
__normal_iterator&
operator--()
;
__normal_iterator
operator--(int)
;
reference
operator[](difference_type __n) const
;
__normal_iterator&
operator+=(difference_type __n)
;
__normal_iterator
operator+(difference_type __n) const
;
__normal_iterator&
operator-=(difference_type __n)
;
__normal_iterator
operator-(difference_type __n) const
;
const _Iterator&
base() const
;
};
template<typename _IteratorL, typename _IteratorR, typename _Container>
bool
operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
;
template<typename _Iterator, typename _Container>
bool
operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
;
template<typename _IteratorL, typename _IteratorR, typename _Container>
bool
operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
;
template<typename _Iterator, typename _Container>
bool
operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
;
template<typename _IteratorL, typename _IteratorR, typename _Container>
bool
operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
;
template<typename _Iterator, typename _Container>
bool
operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
;
template<typename _IteratorL, typename _IteratorR, typename _Container>
bool
operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
;
template<typename _Iterator, typename _Container>
bool
operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
;
template<typename _IteratorL, typename _IteratorR, typename _Container>
bool
operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
;
template<typename _Iterator, typename _Container>
bool
operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
;
template<typename _IteratorL, typename _IteratorR, typename _Container>
bool
operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
;
template<typename _Iterator, typename _Container>
bool
operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
;
template<typename _IteratorL, typename _IteratorR, typename _Container>
typename __normal_iterator<_IteratorL, _Container>::difference_type
operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
;
template<typename _Iterator, typename _Container>
typename __normal_iterator<_Iterator, _Container>::difference_type
operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
;
template<typename _Iterator, typename _Container>
__normal_iterator<_Iterator, _Container>
operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
__n, const __normal_iterator<_Iterator, _Container>& __i)
;
}
namespace __gnu_cxx
{
namespace __ops
{
struct _Iter_less_iter
{
template<typename _Iterator1, typename _Iterator2>
bool
operator()(_Iterator1 __it1, _Iterator2 __it2) const
;
};
_Iter_less_iter
__iter_less_iter()
;
struct _Iter_less_val
{
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val) const
;
};
_Iter_less_val
__iter_less_val()
;
_Iter_less_val
__iter_comp_val(_Iter_less_iter)
;
struct _Val_less_iter
{
template<typename _Value, typename _Iterator>
bool
operator()(_Value& __val, _Iterator __it) const
;
};
_Val_less_iter
__val_less_iter()
;
_Val_less_iter
__val_comp_iter(_Iter_less_iter)
;
struct _Iter_equal_to_iter
{
template<typename _Iterator1, typename _Iterator2>
bool
operator()(_Iterator1 __it1, _Iterator2 __it2) const
;
};
_Iter_equal_to_iter
__iter_equal_to_iter()
;
struct _Iter_equal_to_val
{
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val) const
;
};
_Iter_equal_to_val
__iter_equal_to_val()
;
_Iter_equal_to_val
__iter_comp_val(_Iter_equal_to_iter)
;
template<typename _Compare>
struct _Iter_comp_iter
{
_Compare _M_comp;
_Iter_comp_iter(_Compare __comp)
;
template<typename _Iterator1, typename _Iterator2>
bool
operator()(_Iterator1 __it1, _Iterator2 __it2)
;
};
template<typename _Compare>
_Iter_comp_iter<_Compare>
__iter_comp_iter(_Compare __comp)
;
template<typename _Compare>
struct _Iter_comp_val
{
_Compare _M_comp;
_Iter_comp_val(_Compare __comp)
;
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val)
;
};
template<typename _Compare>
_Iter_comp_val<_Compare>
__iter_comp_val(_Compare __comp)
;
template<typename _Compare>
_Iter_comp_val<_Compare>
__iter_comp_val(_Iter_comp_iter<_Compare> __comp)
;
template<typename _Compare>
struct _Val_comp_iter
{
_Compare _M_comp;
_Val_comp_iter(_Compare __comp)
;
template<typename _Value, typename _Iterator>
bool
operator()(_Value& __val, _Iterator __it)
;
};
template<typename _Compare>
_Val_comp_iter<_Compare>
__val_comp_iter(_Compare __comp)
;
template<typename _Compare>
_Val_comp_iter<_Compare>
__val_comp_iter(_Iter_comp_iter<_Compare> __comp)
;
template<typename _Value>
struct _Iter_equals_val
{
_Value& _M_value;
_Iter_equals_val(_Value& __value)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Value>
_Iter_equals_val<_Value>
__iter_equals_val(_Value& __val)
;
template<typename _Iterator1>
struct _Iter_equals_iter
{
typename std::iterator_traits<_Iterator1>::reference _M_ref;
_Iter_equals_iter(_Iterator1 __it1)
;
template<typename _Iterator2>
bool
operator()(_Iterator2 __it2)
;
};
template<typename _Iterator>
_Iter_equals_iter<_Iterator>
__iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
;
template<typename _Predicate>
struct _Iter_pred
{
_Predicate _M_pred;
_Iter_pred(_Predicate __pred)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Predicate>
_Iter_pred<_Predicate>
__pred_iter(_Predicate __pred)
;
template<typename _Compare, typename _Value>
struct _Iter_comp_to_val
{
_Compare _M_comp;
_Value& _M_value;
_Iter_comp_to_val(_Compare __comp, _Value& __value)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Compare, typename _Value>
_Iter_comp_to_val<_Compare, _Value>
__iter_comp_val(_Compare __comp, _Value &__val)
;
template<typename _Compare, typename _Iterator1>
struct _Iter_comp_to_iter
{
_Compare _M_comp;
typename std::iterator_traits<_Iterator1>::reference _M_ref;
_Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
;
template<typename _Iterator2>
bool
operator()(_Iterator2 __it2)
;
};
template<typename _Compare, typename _Iterator>
_Iter_comp_to_iter<_Compare, _Iterator>
__iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
;
template<typename _Predicate>
struct _Iter_negate
{
_Predicate _M_pred;
_Iter_negate(_Predicate __pred)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Predicate>
_Iter_negate<_Predicate>
__negate(_Iter_pred<_Predicate> __pred)
;
}
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<bool _BoolType>
struct __iter_swap
{
template<typename _ForwardIterator1, typename _ForwardIterator2>
static void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
;
};
template<>
struct __iter_swap<true>
{
template<typename _ForwardIterator1, typename _ForwardIterator2>
static void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
;
};
template<typename _ForwardIterator1, typename _ForwardIterator2>
void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
;
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator2
swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
;
template<typename _Tp>
const _Tp&
min(const _Tp& __a, const _Tp& __b)
;
template<typename _Tp>
const _Tp&
max(const _Tp& __a, const _Tp& __b)
;
template<typename _Tp, typename _Compare>
const _Tp&
min(const _Tp& __a, const _Tp& __b, _Compare __comp)
;
template<typename _Tp, typename _Compare>
const _Tp&
max(const _Tp& __a, const _Tp& __b, _Compare __comp)
;
template<typename _Iterator>
struct _Niter_base
: _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
{ };
template<typename _Iterator>
typename _Niter_base<_Iterator>::iterator_type
__niter_base(_Iterator __it)
;
template<typename _Iterator>
struct _Miter_base
: _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
{ };
template<typename _Iterator>
typename _Miter_base<_Iterator>::iterator_type
__miter_base(_Iterator __it)
;
template<bool, bool, typename>
struct __copy_move
{
template<typename _II, typename _OI>
static _OI
__copy_m(_II __first, _II __last, _OI __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)
;
};
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)
;
};
template<bool _IsMove, typename _II, typename _OI>
_OI
__copy_move_a(_II __first, _II __last, _OI __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>
_OI
__copy_move_a2(_II __first, _II __last, _OI __result)
;
template<typename _II, typename _OI>
_OI
copy(_II __first, _II __last, _OI __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)
;
};
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)
;
};
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)
;
};
template<bool _IsMove, typename _BI1, typename _BI2>
_BI2
__copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
;
template<bool _IsMove, typename _BI1, typename _BI2>
_BI2
__copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
;
template<typename _BI1, typename _BI2>
_BI2
copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
;
template<typename _ForwardIterator, typename _Tp>
typename
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
;
template<typename _ForwardIterator, typename _Tp>
typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
;
template<typename _Tp>
typename
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
__fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
;
template<typename _ForwardIterator, typename _Tp>
void
fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
;
template<typename _OutputIterator, typename _Size, typename _Tp>
typename
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
;
template<typename _OutputIterator, typename _Size, typename _Tp>
typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
;
template<typename _Size, typename _Tp>
typename
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
__fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
;
template<typename _OI, typename _Size, typename _Tp>
_OI
fill_n(_OI __first, _Size __n, const _Tp& __value)
;
template<bool _BoolType>
struct __equal
{
template<typename _II1, typename _II2>
static bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
;
};
template<>
struct __equal<true>
{
template<typename _Tp>
static bool
equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
;
};
template<typename _II1, typename _II2>
bool
__equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
;
template<typename, typename>
struct __lc_rai
{
template<typename _II1, typename _II2>
static _II1
__newlast1(_II1, _II1 __last1, _II2, _II2)
;
template<typename _II>
static bool
__cnd2(_II __first, _II __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)
;
template<typename _RAI>
static bool
__cnd2(_RAI, _RAI)
;
};
template<typename _II1, typename _II2, typename _Compare>
bool
__lexicographical_compare_impl(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2,
_Compare __comp)
;
template<bool _BoolType>
struct __lexicographical_compare
{
template<typename _II1, typename _II2>
static bool __lc(_II1, _II1, _II2, _II2);
};
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)
;
};
template<typename _II1, typename _II2>
bool
__lexicographical_compare_aux(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
__lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp>
_ForwardIterator
lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
;
int
__lg(int __n)
;
unsigned
__lg(unsigned __n)
;
long
__lg(long __n)
;
unsigned long
__lg(unsigned long __n)
;
long long
__lg(long long __n)
;
unsigned long long
__lg(unsigned long long __n)
;
template<typename _II1, typename _II2>
bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
;
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
bool
equal(_IIter1 __first1, _IIter1 __last1,
_IIter2 __first2, _BinaryPredicate __binary_pred)
;
template<typename _II1, typename _II2>
bool
lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2)
;
template<typename _II1, typename _II2, typename _Compare>
bool
lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
pair<_InputIterator1, _InputIterator2>
__mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred)
;
template<typename _InputIterator1, typename _InputIterator2>
pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred)
;
}
struct _IO_FILE;
typedef struct _IO_FILE FILE;
typedef struct _IO_FILE __FILE;
typedef __builtin_va_list __gnuc_va_list;
typedef long unsigned int size_t;
typedef unsigned int wint_t;
typedef struct
{
int __count;
union
{
unsigned int __wch;
char __wchb[4];
} __value;
} __mbstate_t;
typedef __mbstate_t mbstate_t;
extern "C" {
struct tm;
extern wchar_t *wcscpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern wchar_t *wcscat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern wchar_t *wcsncat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
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 ();
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;
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__));
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 __attribute__ ((__gnu_inline__)) wint_t
__attribute__ ((__leaf__)) btowc (int __c) throw ()
;
extern int __wctob_alias (wint_t __c) __asm ("wctob");
extern __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) wctob (wint_t __wc) throw ()
;
extern __attribute__ ((__gnu_inline__)) size_t
__attribute__ ((__leaf__)) mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw ()
;
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 ();
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 () ;
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 () ;
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);
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);
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
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 ();
extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n,
size_t __ns1) throw ();
extern wchar_t *__wmemcpy_alias (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw () __asm__ ("" "wmemcpy")
;
extern wchar_t *__wmemcpy_chk_warn (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmemcpy_chk")
__attribute__((__warning__ ("wmemcpy called with length bigger than size of destination " "buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wmemcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw ()
;
extern wchar_t *__wmemmove_chk (wchar_t *__s1, const wchar_t *__s2,
size_t __n, size_t __ns1) throw ();
extern wchar_t *__wmemmove_alias (wchar_t *__s1, const wchar_t *__s2, size_t __n) throw () __asm__ ("" "wmemmove")
;
extern wchar_t *__wmemmove_chk_warn (wchar_t *__s1, const wchar_t *__s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmemmove_chk")
__attribute__((__warning__ ("wmemmove called with length bigger than size of destination " "buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) throw ()
;
extern wchar_t *__wmempcpy_chk (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n,
size_t __ns1) throw ();
extern wchar_t *__wmempcpy_alias (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw () __asm__ ("" "wmempcpy")
;
extern wchar_t *__wmempcpy_chk_warn (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmempcpy_chk")
__attribute__((__warning__ ("wmempcpy called with length bigger than size of destination " "buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wmempcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw ()
;
extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n,
size_t __ns) throw ();
extern wchar_t *__wmemset_alias (wchar_t *__s, wchar_t __c, size_t __n) throw () __asm__ ("" "wmemset")
;
extern wchar_t *__wmemset_chk_warn (wchar_t *__s, wchar_t __c, size_t __n, size_t __ns) throw () __asm__ ("" "__wmemset_chk")
__attribute__((__warning__ ("wmemset called with length bigger than size of destination " "buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ()
;
extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest,
const wchar_t *__restrict __src,
size_t __n) throw ();
extern wchar_t *__wcscpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw () __asm__ ("" "wcscpy")
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wcscpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw ()
;
extern wchar_t *__wcpcpy_chk (wchar_t *__restrict __dest,
const wchar_t *__restrict __src,
size_t __destlen) throw ();
extern wchar_t *__wcpcpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw () __asm__ ("" "wcpcpy")
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wcpcpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw ()
;
extern wchar_t *__wcsncpy_chk (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n,
size_t __destlen) throw ();
extern wchar_t *__wcsncpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcsncpy")
;
extern wchar_t *__wcsncpy_chk_warn (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen) throw () __asm__ ("" "__wcsncpy_chk")
__attribute__((__warning__ ("wcsncpy called with length bigger than size of destination " "buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wcsncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw ()
;
extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n,
size_t __destlen) throw ();
extern wchar_t *__wcpncpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcpncpy")
;
extern wchar_t *__wcpncpy_chk_warn (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen) throw () __asm__ ("" "__wcpncpy_chk")
__attribute__((__warning__ ("wcpncpy called with length bigger than size of destination " "buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wcpncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw ()
;
extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest,
const wchar_t *__restrict __src,
size_t __destlen) throw ();
extern wchar_t *__wcscat_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw () __asm__ ("" "wcscat")
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wcscat (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw ()
;
extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest,
const wchar_t *__restrict __src,
size_t __n, size_t __destlen) throw ();
extern wchar_t *__wcsncat_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcsncat")
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wcsncat (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw ()
;
extern int __swprintf_chk (wchar_t *__restrict __s, size_t __n,
int __flag, size_t __s_len,
const wchar_t *__restrict __format, ...)
throw () ;
extern int __swprintf_alias (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, ...) throw () __asm__ ("" "swprintf")
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) swprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, ...) throw ()
;
extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n,
int __flag, size_t __s_len,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
extern int __vswprintf_alias (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, __gnuc_va_list __ap) throw () __asm__ ("" "vswprintf")
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) vswprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, __gnuc_va_list __ap) throw ()
;
extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag,
const wchar_t *__restrict __format, ...);
extern int __wprintf_chk (int __flag, const wchar_t *__restrict __format,
...);
extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag,
const wchar_t *__restrict __format,
__gnuc_va_list __ap);
extern int __vwprintf_chk (int __flag, const wchar_t *__restrict __format,
__gnuc_va_list __ap);
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
wprintf (const wchar_t *__restrict __fmt, ...)
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
fwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __fmt, ...)
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
vwprintf (const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
vfwprintf (__FILE *__restrict __stream,
const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
;
extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n,
__FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern wchar_t *__fgetws_alias (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) __asm__ ("" "fgetws")
__attribute__ ((__warn_unused_result__));
extern wchar_t *__fgetws_chk_warn (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __asm__ ("" "__fgetws_chk")
__attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgetws called with bigger size than length " "of destination buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) wchar_t *
fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
;
extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size,
int __n, __FILE *__restrict __stream)
__attribute__ ((__warn_unused_result__));
extern wchar_t *__fgetws_unlocked_alias (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) __asm__ ("" "fgetws_unlocked")
__attribute__ ((__warn_unused_result__));
extern wchar_t *__fgetws_unlocked_chk_warn (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __asm__ ("" "__fgetws_unlocked_chk")
__attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgetws_unlocked called with bigger size than length " "of destination buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) wchar_t *
fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
;
extern size_t __wcrtomb_chk (char *__restrict __s, wchar_t __wchar,
mbstate_t *__restrict __p,
size_t __buflen) throw () __attribute__ ((__warn_unused_result__));
extern size_t __wcrtomb_alias (char *__restrict __s, wchar_t __wchar, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcrtomb")
__attribute__ ((__warn_unused_result__));
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) size_t
__attribute__ ((__leaf__)) wcrtomb (char *__restrict __s, wchar_t __wchar, mbstate_t *__restrict __ps) throw ()
;
extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst,
const char **__restrict __src,
size_t __len, mbstate_t *__restrict __ps,
size_t __dstlen) throw ();
extern size_t __mbsrtowcs_alias (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "mbsrtowcs")
;
extern size_t __mbsrtowcs_chk_warn (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__mbsrtowcs_chk")
__attribute__((__warning__ ("mbsrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__leaf__)) mbsrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ()
;
extern size_t __wcsrtombs_chk (char *__restrict __dst,
const wchar_t **__restrict __src,
size_t __len, mbstate_t *__restrict __ps,
size_t __dstlen) throw ();
extern size_t __wcsrtombs_alias (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcsrtombs")
;
extern size_t __wcsrtombs_chk_warn (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__wcsrtombs_chk")
__attribute__((__warning__ ("wcsrtombs called with dst buffer smaller than len")));
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__leaf__)) wcsrtombs (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ()
;
extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __nmc,
size_t __len, mbstate_t *__restrict __ps,
size_t __dstlen) throw ();
extern size_t __mbsnrtowcs_alias (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "mbsnrtowcs")
;
extern size_t __mbsnrtowcs_chk_warn (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__mbsnrtowcs_chk")
__attribute__((__warning__ ("mbsnrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__leaf__)) mbsnrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) throw ()
;
extern size_t __wcsnrtombs_chk (char *__restrict __dst,
const wchar_t **__restrict __src,
size_t __nwc, size_t __len,
mbstate_t *__restrict __ps, size_t __dstlen)
throw ();
extern size_t __wcsnrtombs_alias (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcsnrtombs")
;
extern size_t __wcsnrtombs_chk_warn (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__wcsnrtombs_chk")
__attribute__((__warning__ ("wcsnrtombs called with dst buffer smaller than len")));
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__leaf__)) wcsnrtombs (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) throw ()
;
}
namespace std
{
using ::mbstate_t;
}
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;
}
namespace __gnu_cxx
{
using ::wcstold;
using ::wcstoll;
using ::wcstoull;
}
namespace std
{
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef long streamoff;
typedef ptrdiff_t streamsize;
template<typename _StateT>
class fpos
{
private:
streamoff _M_off;
_StateT _M_state;
public:
fpos() ;
fpos(streamoff __off) ;
operator streamoff() const ;
void
state(_StateT __st)
;
_StateT
state() const
;
fpos&
operator+=(streamoff __off)
;
fpos&
operator-=(streamoff __off)
;
fpos
operator+(streamoff __off) const
;
fpos
operator-(streamoff __off) const
;
streamoff
operator-(const fpos& __other) const
;
};
template<typename _StateT>
bool
operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
;
template<typename _StateT>
bool
operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
;
typedef fpos<mbstate_t> streampos;
typedef fpos<mbstate_t> wstreampos;
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
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;
};
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)
;
static bool
eq(const char_type& __c1, const char_type& __c2)
;
static bool
lt(const char_type& __c1, const char_type& __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 char_type
to_char_type(const int_type& __c)
;
static int_type
to_int_type(const char_type& __c)
;
static bool
eq_int_type(const int_type& __c1, const int_type& __c2)
;
static int_type
eof()
;
static int_type
not_eof(const int_type& __c)
;
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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)
;
static bool
eq(const char_type& __c1, const char_type& __c2)
;
static bool
lt(const char_type& __c1, const char_type& __c2)
;
static int
compare(const char_type* __s1, const char_type* __s2, size_t __n)
;
static size_t
length(const char_type* __s)
;
static const char_type*
find(const char_type* __s, size_t __n, const char_type& __a)
;
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
;
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
;
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
;
static char_type
to_char_type(const int_type& __c)
;
static int_type
to_int_type(const char_type& __c)
;
static bool
eq_int_type(const int_type& __c1, const int_type& __c2)
;
static int_type
eof()
;
static int_type
not_eof(const int_type& __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)
;
static bool
eq(const char_type& __c1, const char_type& __c2)
;
static bool
lt(const char_type& __c1, const char_type& __c2)
;
static int
compare(const char_type* __s1, const char_type* __s2, size_t __n)
;
static size_t
length(const char_type* __s)
;
static const char_type*
find(const char_type* __s, size_t __n, const char_type& __a)
;
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
;
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
;
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
;
static char_type
to_char_type(const int_type& __c)
;
static int_type
to_int_type(const char_type& __c)
;
static bool
eq_int_type(const int_type& __c1, const int_type& __c2)
;
static int_type
eof()
;
static int_type
not_eof(const int_type& __c)
;
};
}
extern "C++" {
namespace std
{
class exception
{
public:
exception() throw() ;
virtual ~exception() throw();
virtual const char* what() const throw();
};
class bad_exception : public exception
{
public:
bad_exception() throw() ;
virtual ~bad_exception() throw();
virtual const char* what() const throw();
};
typedef void (*terminate_handler) ();
typedef void (*unexpected_handler) ();
terminate_handler set_terminate(terminate_handler) throw();
void terminate() throw() __attribute__ ((__noreturn__));
unexpected_handler set_unexpected(unexpected_handler) throw();
void unexpected() __attribute__ ((__noreturn__));
bool uncaught_exception() throw() __attribute__ ((__pure__));
}
namespace __gnu_cxx
{
void __verbose_terminate_handler();
}
}
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();
}
void* operator new(std::size_t) throw(std::bad_alloc)
__attribute__((__externally_visible__));
void* operator new[](std::size_t) throw(std::bad_alloc)
__attribute__((__externally_visible__));
void operator delete(void*) throw()
__attribute__((__externally_visible__));
void operator delete[](void*) throw()
__attribute__((__externally_visible__));
void* operator new(std::size_t, const std::nothrow_t&) throw()
__attribute__((__externally_visible__));
void* operator new[](std::size_t, const std::nothrow_t&) throw()
__attribute__((__externally_visible__));
void operator delete(void*, const std::nothrow_t&) throw()
__attribute__((__externally_visible__));
void operator delete[](void*, const std::nothrow_t&) throw()
__attribute__((__externally_visible__));
void* operator new(std::size_t, void* __p) throw()
;
void* operator new[](std::size_t, void* __p) throw()
;
void operator delete (void*, void*) throw() ;
void operator delete[](void*, void*) throw() ;
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
using std::size_t;
using std::ptrdiff_t;
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; };
new_allocator() throw() ;
new_allocator(const new_allocator&) throw() ;
template<typename _Tp1>
new_allocator(const new_allocator<_Tp1>&) throw() ;
~new_allocator() throw() ;
pointer
address(reference __x) const
;
const_pointer
address(const_reference __x) const
;
pointer
allocate(size_type __n, const void* = 0)
;
void
deallocate(pointer __p, size_type)
;
size_type
max_size() const throw()
;
void
construct(pointer __p, const _Tp& __val)
;
void
destroy(pointer __p) ;
};
template<typename _Tp>
bool
operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
;
template<typename _Tp>
bool
operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
;
}
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; };
};
template<typename _Tp>
class allocator: public __gnu_cxx::new_allocator<_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; };
allocator() throw() ;
allocator(const allocator& __a) throw() ;
template<typename _Tp1>
allocator(const allocator<_Tp1>&) throw() ;
~allocator() throw() ;
};
template<typename _T1, typename _T2>
bool
operator==(const allocator<_T1>&, const allocator<_T2>&)
throw()
;
template<typename _Tp>
bool
operator==(const allocator<_Tp>&, const allocator<_Tp>&)
throw()
;
template<typename _T1, typename _T2>
bool
operator!=(const allocator<_T1>&, const allocator<_T2>&)
throw()
;
template<typename _Tp>
bool
operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
throw()
;
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)
;
};
template<typename _Alloc, bool = __is_empty(_Alloc)>
struct __alloc_neq
{
static bool
_S_do_it(const _Alloc&, const _Alloc&)
;
};
template<typename _Alloc>
struct __alloc_neq<_Alloc, false>
{
static bool
_S_do_it(const _Alloc& __one, const _Alloc& __two)
;
};
}
extern "C" {
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;
};
extern char *setlocale (int __category, const char *__locale) throw ();
extern struct lconv *localeconv (void) throw ();
extern __locale_t newlocale (int __category_mask, const char *__locale,
__locale_t __base) throw ();
extern __locale_t duplocale (__locale_t __dataset) throw ();
extern void freelocale (__locale_t __dataset) throw ();
extern __locale_t uselocale (__locale_t __dataset) throw ();
}
namespace std
{
using ::lconv;
using ::setlocale;
using ::localeconv;
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
extern "C" __typeof(uselocale) __uselocale;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef __locale_t __c_locale;
int
__convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
char* __out,
const int __size __attribute__ ((__unused__)),
const char* __fmt, ...)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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;
namespace __cxx11 {
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;
}
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;
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;
extern "C" {
static unsigned int
__bswap_32 (unsigned int __bsx)
;
static __uint64_t
__bswap_64 (__uint64_t __bsx)
;
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))
};
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__));
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 ();
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 ();
}
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 __attribute__ ((__visibility__ ("default")))
{
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;
namespace __cxx11 {
template<typename _CharT> class numpunct;
template<typename _CharT> class numpunct_byname;
}
namespace __cxx11 {
template<typename _CharT>
class collate;
template<typename _CharT>
class collate_byname;
}
class time_base;
namespace __cxx11 {
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;
namespace __cxx11 {
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class money_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class money_put;
}
namespace __cxx11 {
template<typename _CharT, bool _Intl = false>
class moneypunct;
template<typename _CharT, bool _Intl = false>
class moneypunct_byname;
}
class messages_base;
namespace __cxx11 {
template<typename _CharT>
class messages;
template<typename _CharT>
class messages_byname;
}
}
namespace __cxxabiv1
{
class __forced_unwind
{
virtual ~__forced_unwind() throw();
virtual void __pure_dummy() = 0;
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
void
__ostream_write(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
;
template<typename _CharT, typename _Traits>
void
__ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
__ostream_insert(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
;
extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
extern template wostream& __ostream_insert(wostream&, const wchar_t*,
streamsize);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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;
};
template<typename _Tp>
struct plus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct minus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct multiplies : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct divides : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct modulus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct negate : public unary_function<_Tp, _Tp>
{
_Tp
operator()(const _Tp& __x) const
;
};
template<typename _Tp>
struct equal_to : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct not_equal_to : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct greater : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct less : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct greater_equal : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct less_equal : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct logical_and : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct logical_or : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct logical_not : public unary_function<_Tp, bool>
{
bool
operator()(const _Tp& __x) const
;
};
template<typename _Tp>
struct bit_and : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct bit_or : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct bit_not : public unary_function<_Tp, _Tp>
{
_Tp
operator()(const _Tp& __x) const
;
};
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) ;
bool
operator()(const typename _Predicate::argument_type& __x) const
;
};
template<typename _Predicate>
unary_negate<_Predicate>
not1(const _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) ;
bool
operator()(const typename _Predicate::first_argument_type& __x,
const typename _Predicate::second_argument_type& __y) const
;
};
template<typename _Predicate>
binary_negate<_Predicate>
not2(const _Predicate& __pred)
;
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)) ;
_Result
operator()(_Arg __x) const
;
};
template<typename _Arg, typename _Result>
pointer_to_unary_function<_Arg, _Result>
ptr_fun(_Result (*__x)(_Arg))
;
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)) ;
_Result
operator()(_Arg1 __x, _Arg2 __y) const
;
};
template<typename _Arg1, typename _Arg2, typename _Result>
pointer_to_binary_function<_Arg1, _Arg2, _Result>
ptr_fun(_Result (*__x)(_Arg1, _Arg2))
;
template<typename _Tp>
struct _Identity
: public unary_function<_Tp,_Tp>
{
_Tp&
operator()(_Tp& __x) const
;
const _Tp&
operator()(const _Tp& __x) const
;
};
template<typename _Pair>
struct _Select1st
: public unary_function<_Pair, typename _Pair::first_type>
{
typename _Pair::first_type&
operator()(_Pair& __x) const
;
const typename _Pair::first_type&
operator()(const _Pair& __x) const
;
};
template<typename _Pair>
struct _Select2nd
: public unary_function<_Pair, typename _Pair::second_type>
{
typename _Pair::second_type&
operator()(_Pair& __x) const
;
const typename _Pair::second_type&
operator()(const _Pair& __x) const
;
};
template<typename _Ret, typename _Tp>
class mem_fun_t : public unary_function<_Tp*, _Ret>
{
public:
explicit
mem_fun_t(_Ret (_Tp::*__pf)()) ;
_Ret
operator()(_Tp* __p) const
;
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) ;
_Ret
operator()(const _Tp* __p) const
;
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)()) ;
_Ret
operator()(_Tp& __r) const
;
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) ;
_Ret
operator()(const _Tp& __r) const
;
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)) ;
_Ret
operator()(_Tp* __p, _Arg __x) const
;
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) ;
_Ret
operator()(const _Tp* __p, _Arg __x) const
;
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)) ;
_Ret
operator()(_Tp& __r, _Arg __x) const
;
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) ;
_Ret
operator()(const _Tp& __r, _Arg __x) const
;
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
template<typename _Ret, typename _Tp>
mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)())
;
template<typename _Ret, typename _Tp>
const_mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)() const)
;
template<typename _Ret, typename _Tp>
mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)())
;
template<typename _Ret, typename _Tp>
const_mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)() const)
;
template<typename _Ret, typename _Tp, typename _Arg>
mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg))
;
template<typename _Ret, typename _Tp, typename _Arg>
const_mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg) const)
;
template<typename _Ret, typename _Tp, typename _Arg>
mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
;
template<typename _Ret, typename _Tp, typename _Arg>
const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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) ;
typename _Operation::result_type
operator()(const typename _Operation::second_argument_type& __x) const
;
typename _Operation::result_type
operator()(typename _Operation::second_argument_type& __x) const
;
} ;
template<typename _Operation, typename _Tp>
binder1st<_Operation>
bind1st(const _Operation& __fn, const _Tp& __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) ;
typename _Operation::result_type
operator()(const typename _Operation::first_argument_type& __x) const
;
typename _Operation::result_type
operator()(typename _Operation::first_argument_type& __x) const
;
} ;
template<typename _Operation, typename _Tp>
binder2nd<_Operation>
bind2nd(const _Operation& __fn, const _Tp& __x)
;
}
typedef __time_t time_t;
struct timespec
{
__time_t tv_sec;
__syscall_slong_t tv_nsec;
};
typedef __pid_t pid_t;
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;
};
typedef unsigned long int __cpu_mask;
typedef struct
{
__cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
} cpu_set_t;
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 () __attribute__ ((__warn_unused_result__));
extern void __sched_cpufree (cpu_set_t *__set) throw ();
}
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 ();
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 ();
}
extern "C" {
struct timeval
{
__time_t tv_sec;
__suseconds_t tv_usec;
};
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;
};
extern "C" {
extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
}
typedef __clock_t clock_t;
typedef __clockid_t clockid_t;
typedef __timer_t timer_t;
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;
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 ();
extern time_t timegm (struct tm *__tp) throw ();
extern time_t timelocal (struct tm *__tp) throw ();
extern int dysize (int __year) throw () __attribute__ ((__const__));
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)));
extern int getdate_err;
extern struct tm *getdate (const char *__string);
extern int getdate_r (const char *__restrict __string,
struct tm *__restrict __resbufp);
}
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;
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;
} __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;
signed char __rwelision;
unsigned char __pad1[7];
unsigned long int __pad2;
unsigned int __flags;
} __data;
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;
typedef long int __jmp_buf[8];
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
};
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
};
enum
{
PTHREAD_INHERIT_SCHED,
PTHREAD_EXPLICIT_SCHED
};
enum
{
PTHREAD_SCOPE_SYSTEM,
PTHREAD_SCOPE_PROCESS
};
enum
{
PTHREAD_PROCESS_PRIVATE,
PTHREAD_PROCESS_SHARED
};
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
};
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)));
extern int pthread_once (pthread_once_t *__once_control,
void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
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__));
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) ;
~__pthread_cleanup_class () ;
void __setdoit (int __newval) ;
void __defer () ;
void __restore () const ;
};
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)));
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)));
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)));
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)));
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)));
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)));
extern int pthread_atfork (void (*__prepare) (void),
void (*__parent) (void),
void (*__child) (void)) throw ();
extern __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ()
;
}
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;
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")));
static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create")));
static int
__gthread_active_p (void)
;
static int
__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
void *__args)
;
static int
__gthread_join (__gthread_t __threadid, void **__value_ptr)
;
static int
__gthread_detach (__gthread_t __threadid)
;
static int
__gthread_equal (__gthread_t __t1, __gthread_t __t2)
;
static __gthread_t
__gthread_self (void)
;
static int
__gthread_yield (void)
;
static int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
;
static int
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
;
static int
__gthread_key_delete (__gthread_key_t __key)
;
static void *
__gthread_getspecific (__gthread_key_t __key)
;
static int
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
;
static void
__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
;
static int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
;
static int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_cond_broadcast (__gthread_cond_t *__cond)
;
static int
__gthread_cond_signal (__gthread_cond_t *__cond)
;
static int
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
;
static int
__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
;
static int
__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_cond_destroy (__gthread_cond_t* __cond)
;
typedef int _Atomic_word;
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
static _Atomic_word
__exchange_and_add(volatile _Atomic_word* __mem, int __val)
;
static void
__atomic_add(volatile _Atomic_word* __mem, int __val)
;
static _Atomic_word
__exchange_and_add_single(_Atomic_word* __mem, int __val)
;
static void
__atomic_add_single(_Atomic_word* __mem, int __val)
;
static _Atomic_word
__attribute__ ((__unused__))
__exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
;
static void
__attribute__ ((__unused__))
__atomic_add_dispatch(_Atomic_word* __mem, int __val)
;
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
struct __alloc_traits
{
typedef _Alloc allocator_type;
typedef typename _Alloc::pointer pointer;
typedef typename _Alloc::const_pointer const_pointer;
typedef typename _Alloc::value_type value_type;
typedef typename _Alloc::reference reference;
typedef typename _Alloc::const_reference const_reference;
typedef typename _Alloc::size_type size_type;
typedef typename _Alloc::difference_type difference_type;
static pointer
allocate(_Alloc& __a, size_type __n)
;
static void deallocate(_Alloc& __a, pointer __p, size_type __n)
;
template<typename _Tp>
static void construct(_Alloc& __a, pointer __p, const _Tp& __arg)
;
static void destroy(_Alloc& __a, pointer __p)
;
static size_type max_size(const _Alloc& __a)
;
static const _Alloc& _S_select_on_copy(const _Alloc& __a) ;
static void _S_on_swap(_Alloc& __a, _Alloc& __b)
;
template<typename _Tp>
struct rebind
{ typedef typename _Alloc::template rebind<_Tp>::other other; };
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace __cxx11 {
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_string
{
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
rebind<_CharT>::other _Char_alloc_type;
typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
public:
typedef _Traits traits_type;
typedef typename _Traits::char_type value_type;
typedef _Char_alloc_type allocator_type;
typedef typename _Alloc_traits::size_type size_type;
typedef typename _Alloc_traits::difference_type difference_type;
typedef typename _Alloc_traits::reference reference;
typedef typename _Alloc_traits::const_reference const_reference;
typedef typename _Alloc_traits::pointer pointer;
typedef typename _Alloc_traits::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;
static const size_type npos = static_cast<size_type>(-1);
private:
typedef iterator __const_iterator;
struct _Alloc_hider : allocator_type
{
_Alloc_hider(pointer __dat, const _Alloc& __a = _Alloc()) ;
pointer _M_p;
};
_Alloc_hider _M_dataplus;
size_type _M_string_length;
enum { _S_local_capacity = 15 / sizeof(_CharT) };
union
{
_CharT _M_local_buf[_S_local_capacity + 1];
size_type _M_allocated_capacity;
};
void
_M_data(pointer __p)
;
void
_M_length(size_type __length)
;
pointer
_M_data() const
;
pointer
_M_local_data()
;
const_pointer
_M_local_data() const
;
void
_M_capacity(size_type __capacity)
;
void
_M_set_length(size_type __n)
;
bool
_M_is_local() const
;
pointer
_M_create(size_type&, size_type);
void
_M_dispose()
;
void
_M_destroy(size_type __size) throw()
;
template<typename _InIterator>
void
_M_construct_aux(_InIterator __beg, _InIterator __end,
std::__false_type)
;
template<typename _Integer>
void
_M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
;
void
_M_construct_aux_2(size_type __req, _CharT __c)
;
template<typename _InIterator>
void
_M_construct(_InIterator __beg, _InIterator __end)
;
template<typename _InIterator>
void
_M_construct(_InIterator __beg, _InIterator __end,
std::input_iterator_tag);
template<typename _FwdIterator>
void
_M_construct(_FwdIterator __beg, _FwdIterator __end,
std::forward_iterator_tag);
void
_M_construct(size_type __req, _CharT __c);
allocator_type&
_M_get_allocator()
;
const allocator_type&
_M_get_allocator() const
;
private:
size_type
_M_check(size_type __pos, const char* __s) const
;
void
_M_check_length(size_type __n1, size_type __n2, const char* __s) const
;
size_type
_M_limit(size_type __pos, size_type __off) const
;
bool
_M_disjunct(const _CharT* __s) const
;
static void
_S_copy(_CharT* __d, const _CharT* __s, size_type __n)
;
static void
_S_move(_CharT* __d, const _CharT* __s, size_type __n)
;
static void
_S_assign(_CharT* __d, size_type __n, _CharT __c)
;
template<class _Iterator>
static void
_S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
;
static void
_S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
;
static void
_S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
;
static void
_S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
;
static void
_S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
;
static int
_S_compare(size_type __n1, size_type __n2)
;
void
_M_assign(const basic_string& __rcs);
void
_M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
size_type __len2);
void
_M_erase(size_type __pos, size_type __n);
public:
basic_string()
;
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)
;
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())
;
template<typename _InputIterator>
basic_string(_InputIterator __beg, _InputIterator __end,
const _Alloc& __a = _Alloc())
;
~basic_string()
;
basic_string&
operator=(const basic_string& __str)
;
basic_string&
operator=(const _CharT* __s)
;
basic_string&
operator=(_CharT __c)
;
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
;
public:
size_type
size() const
;
size_type
length() const
;
size_type
max_size() const
;
void
resize(size_type __n, _CharT __c);
void
resize(size_type __n)
;
size_type
capacity() const
;
void
reserve(size_type __res_arg = 0);
void
clear()
;
bool
empty() const
;
const_reference
operator[] (size_type __pos) const
;
reference
operator[](size_type __pos)
;
const_reference
at(size_type __n) const
;
reference
at(size_type __n)
;
basic_string&
operator+=(const basic_string& __str)
;
basic_string&
operator+=(const _CharT* __s)
;
basic_string&
operator+=(_CharT __c)
;
basic_string&
append(const basic_string& __str)
;
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)
;
basic_string&
append(size_type __n, _CharT __c)
;
template<class _InputIterator>
basic_string&
append(_InputIterator __first, _InputIterator __last)
;
void
push_back(_CharT __c)
;
basic_string&
assign(const basic_string& __str)
;
basic_string&
assign(const basic_string& __str, size_type __pos, size_type __n)
;
basic_string&
assign(const _CharT* __s, size_type __n)
;
basic_string&
assign(const _CharT* __s)
;
basic_string&
assign(size_type __n, _CharT __c)
;
template<class _InputIterator>
basic_string&
assign(_InputIterator __first, _InputIterator __last)
;
void
insert(iterator __p, size_type __n, _CharT __c)
;
template<class _InputIterator>
void
insert(iterator __p, _InputIterator __beg, _InputIterator __end)
;
basic_string&
insert(size_type __pos1, const basic_string& __str)
;
basic_string&
insert(size_type __pos1, const basic_string& __str,
size_type __pos2, size_type __n)
;
basic_string&
insert(size_type __pos, const _CharT* __s, size_type __n)
;
basic_string&
insert(size_type __pos, const _CharT* __s)
;
basic_string&
insert(size_type __pos, size_type __n, _CharT __c)
;
iterator
insert(__const_iterator __p, _CharT __c)
;
basic_string&
erase(size_type __pos = 0, size_type __n = npos)
;
iterator
erase(__const_iterator __position)
;
iterator
erase(__const_iterator __first, __const_iterator __last)
;
basic_string&
replace(size_type __pos, size_type __n, const basic_string& __str)
;
basic_string&
replace(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2)
;
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2)
;
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s)
;
basic_string&
replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
;
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
const basic_string& __str)
;
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
const _CharT* __s, size_type __n)
;
basic_string&
replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
;
basic_string&
replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
_CharT __c)
;
template<class _InputIterator>
basic_string&
replace(iterator __i1, iterator __i2,
_InputIterator __k1, _InputIterator __k2)
;
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
_CharT* __k1, _CharT* __k2)
;
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
const _CharT* __k1, const _CharT* __k2)
;
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
iterator __k1, iterator __k2)
;
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
const_iterator __k1, const_iterator __k2)
;
private:
template<class _Integer>
basic_string&
_M_replace_dispatch(const_iterator __i1, const_iterator __i2,
_Integer __n, _Integer __val, __true_type)
;
template<class _InputIterator>
basic_string&
_M_replace_dispatch(const_iterator __i1, const_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(size_type __pos, size_type __len1, const _CharT* __s,
const size_type __len2);
basic_string&
_M_append(const _CharT* __s, size_type __n);
public:
size_type
copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
void
swap(basic_string& __s) ;
const _CharT*
c_str() const
;
const _CharT*
data() const
;
allocator_type
get_allocator() const
;
size_type
find(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
find(const basic_string& __str, size_type __pos = 0) const
;
size_type
find(const _CharT* __s, size_type __pos = 0) const
;
size_type
find(_CharT __c, size_type __pos = 0) const ;
size_type
rfind(const basic_string& __str, size_type __pos = npos) const
;
size_type
rfind(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
rfind(const _CharT* __s, size_type __pos = npos) const
;
size_type
rfind(_CharT __c, size_type __pos = npos) const ;
size_type
find_first_of(const basic_string& __str, size_type __pos = 0) const
;
size_type
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
find_first_of(const _CharT* __s, size_type __pos = 0) const
;
size_type
find_first_of(_CharT __c, size_type __pos = 0) const
;
size_type
find_last_of(const basic_string& __str, size_type __pos = npos) const
;
size_type
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
find_last_of(const _CharT* __s, size_type __pos = npos) const
;
size_type
find_last_of(_CharT __c, size_type __pos = npos) const
;
size_type
find_first_not_of(const basic_string& __str, size_type __pos = 0) const
;
size_type
find_first_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
size_type
find_first_not_of(const _CharT* __s, size_type __pos = 0) const
;
size_type
find_first_not_of(_CharT __c, size_type __pos = 0) const
;
size_type
find_last_not_of(const basic_string& __str, size_type __pos = npos) const
;
size_type
find_last_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
size_type
find_last_not_of(const _CharT* __s, size_type __pos = npos) const
;
size_type
find_last_not_of(_CharT __c, size_type __pos = npos) const
;
basic_string
substr(size_type __pos = 0, size_type __n = npos) const
;
int
compare(const basic_string& __str) const
;
int
compare(size_type __pos, size_type __n, const basic_string& __str) const;
int
compare(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2) const;
int
compare(const _CharT* __s) const;
int
compare(size_type __pos, size_type __n1, const _CharT* __s) const;
int
compare(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2) const;
};
}
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)
;
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>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
operator==(const basic_string<_CharT>& __lhs,
const basic_string<_CharT>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator==(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator!=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
void
swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
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);
template<typename _CharT, typename _Traits, typename _Alloc>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os,
const basic_string<_CharT, _Traits, _Alloc>& __str)
;
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);
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str)
;
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);
}
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>::npos;
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>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in,
basic_string<_CharT, _Traits, _Alloc>& __str)
;
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)
;
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&);
}
typedef long int ptrdiff_t;
extern "C" {
typedef __ssize_t ssize_t;
typedef __gid_t gid_t;
typedef __uid_t uid_t;
typedef __off_t off_t;
typedef __off64_t off64_t;
typedef __useconds_t useconds_t;
typedef __intptr_t intptr_t;
typedef __socklen_t socklen_t;
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))) __attribute__ ((__warn_unused_result__));
extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
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) __attribute__ ((__warn_unused_result__));
extern ssize_t write (int __fd, const void *__buf, size_t __n) __attribute__ ((__warn_unused_result__));
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
__off_t __offset) __attribute__ ((__warn_unused_result__));
extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
__off_t __offset) __attribute__ ((__warn_unused_result__));
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
__off64_t __offset) __attribute__ ((__warn_unused_result__));
extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
__off64_t __offset) __attribute__ ((__warn_unused_result__));
extern int pipe (int __pipedes[2]) throw () __attribute__ ((__warn_unused_result__));
extern int pipe2 (int __pipedes[2], int __flags) throw () __attribute__ ((__warn_unused_result__));
extern unsigned int alarm (unsigned int __seconds) throw ();
extern unsigned int sleep (unsigned int __seconds);
extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
throw ();
extern int usleep (__useconds_t __useconds);
extern int pause (void);
extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () __attribute__ ((__warn_unused_result__));
extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int fchownat (int __fd, const char *__file, __uid_t __owner,
__gid_t __group, int __flag)
throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
extern int chdir (const char *__path) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int fchdir (int __fd) throw () __attribute__ ((__warn_unused_result__));
extern char *getcwd (char *__buf, size_t __size) throw () __attribute__ ((__warn_unused_result__));
extern char *get_current_dir_name (void) throw ();
extern char *getwd (char *__buf)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__));
extern int dup (int __fd) throw () __attribute__ ((__warn_unused_result__));
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 () __attribute__ ((__warn_unused_result__));
extern void _exit (int __status) __attribute__ ((__noreturn__));
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
};
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 ();
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 ();
extern int setpgrp (void) throw ();
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 () __attribute__ ((__warn_unused_result__));
extern int group_member (__gid_t __gid) throw ();
extern int setuid (__uid_t __uid) throw () __attribute__ ((__warn_unused_result__));
extern int setreuid (__uid_t __ruid, __uid_t __euid) throw () __attribute__ ((__warn_unused_result__));
extern int seteuid (__uid_t __uid) throw () __attribute__ ((__warn_unused_result__));
extern int setgid (__gid_t __gid) throw () __attribute__ ((__warn_unused_result__));
extern int setregid (__gid_t __rgid, __gid_t __egid) throw () __attribute__ ((__warn_unused_result__));
extern int setegid (__gid_t __gid) throw () __attribute__ ((__warn_unused_result__));
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 () __attribute__ ((__warn_unused_result__));
extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
throw () __attribute__ ((__warn_unused_result__));
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))) __attribute__ ((__warn_unused_result__));
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))) __attribute__ ((__warn_unused_result__));
extern int linkat (int __fromfd, const char *__from, int __tofd,
const char *__to, int __flags)
throw () __attribute__ ((__nonnull__ (2, 4))) __attribute__ ((__warn_unused_result__));
extern int symlink (const char *__from, const char *__to)
throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
extern ssize_t readlink (const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
extern int symlinkat (const char *__from, int __tofd,
const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));
extern ssize_t readlinkat (int __fd, const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
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)));
extern "C" {
extern char *optarg;
extern int optind;
extern int opterr;
extern int optopt;
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
throw ();
}
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))) __attribute__ ((__warn_unused_result__));
extern int sethostid (long int __id) throw () __attribute__ ((__warn_unused_result__));
extern int getdomainname (char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int setdomainname (const char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int vhangup (void) throw ();
extern int revoke (const char *__file) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
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 () __attribute__ ((__warn_unused_result__));
extern int chroot (const char *__path) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
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 ();
extern int truncate (const char *__file, __off_t __length)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int truncate64 (const char *__file, __off64_t __length)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int ftruncate (int __fd, __off_t __length) throw () __attribute__ ((__warn_unused_result__));
extern int ftruncate64 (int __fd, __off64_t __length) throw () __attribute__ ((__warn_unused_result__));
extern int brk (void *__addr) throw () __attribute__ ((__warn_unused_result__));
extern void *sbrk (intptr_t __delta) throw ();
extern long int syscall (long int __sysno, ...) throw ();
extern int lockf (int __fd, int __cmd, __off_t __len) __attribute__ ((__warn_unused_result__));
extern int lockf64 (int __fd, int __cmd, __off64_t __len) __attribute__ ((__warn_unused_result__));
extern int fdatasync (int __fildes);
extern char *crypt (const char *__key, const char *__salt)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void encrypt (char *__glibc_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)));
extern ssize_t __read_chk (int __fd, void *__buf, size_t __nbytes,
size_t __buflen) __attribute__ ((__warn_unused_result__));
extern ssize_t __read_alias (int __fd, void *__buf, size_t __nbytes) __asm__ ("" "read")
__attribute__ ((__warn_unused_result__));
extern ssize_t __read_chk_warn (int __fd, void *__buf, size_t __nbytes, size_t __buflen) __asm__ ("" "__read_chk")
__attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("read called with bigger length than size of " "the destination buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
read (int __fd, void *__buf, size_t __nbytes)
;
extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes,
__off_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
extern ssize_t __pread64_chk (int __fd, void *__buf, size_t __nbytes,
__off64_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
extern ssize_t __pread_alias (int __fd, void *__buf, size_t __nbytes, __off_t __offset) __asm__ ("" "pread")
__attribute__ ((__warn_unused_result__));
extern ssize_t __pread64_alias (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64")
__attribute__ ((__warn_unused_result__));
extern ssize_t __pread_chk_warn (int __fd, void *__buf, size_t __nbytes, __off_t __offset, size_t __bufsize) __asm__ ("" "__pread_chk")
__attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread called with bigger length than size of " "the destination buffer")))
;
extern ssize_t __pread64_chk_warn (int __fd, void *__buf, size_t __nbytes, __off64_t __offset, size_t __bufsize) __asm__ ("" "__pread64_chk")
__attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread64 called with bigger length than size of " "the destination buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
pread (int __fd, void *__buf, size_t __nbytes, __off_t __offset)
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
;
extern ssize_t __readlink_chk (const char *__restrict __path,
char *__restrict __buf, size_t __len,
size_t __buflen)
throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlink_alias (const char *__restrict __path, char *__restrict __buf, size_t __len) throw () __asm__ ("" "readlink")
__attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlink_chk_warn (const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) throw () __asm__ ("" "__readlink_chk")
__attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlink called with bigger length " "than size of destination buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) ssize_t
__attribute__ ((__leaf__)) readlink (const char *__restrict __path, char *__restrict __buf, size_t __len) throw ()
;
extern ssize_t __readlinkat_chk (int __fd, const char *__restrict __path,
char *__restrict __buf, size_t __len,
size_t __buflen)
throw () __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlinkat_alias (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len) throw () __asm__ ("" "readlinkat")
__attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlinkat_chk_warn (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) throw () __asm__ ("" "__readlinkat_chk")
__attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlinkat called with bigger " "length than size of destination " "buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) ssize_t
__attribute__ ((__leaf__)) readlinkat (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len) throw ()
;
extern char *__getcwd_chk (char *__buf, size_t __size, size_t __buflen)
throw () __attribute__ ((__warn_unused_result__));
extern char *__getcwd_alias (char *__buf, size_t __size) throw () __asm__ ("" "getcwd")
__attribute__ ((__warn_unused_result__));
extern char *__getcwd_chk_warn (char *__buf, size_t __size, size_t __buflen) throw () __asm__ ("" "__getcwd_chk")
__attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getcwd caller with bigger length than size of " "destination buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
__attribute__ ((__leaf__)) getcwd (char *__buf, size_t __size) throw ()
;
extern char *__getwd_chk (char *__buf, size_t buflen)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern char *__getwd_warn (char *__buf) throw () __asm__ ("" "getwd")
__attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("please use getcwd instead, as getwd " "doesn't specify buffer size")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__)) char *
__attribute__ ((__leaf__)) getwd (char *__buf) throw ()
;
extern size_t __confstr_chk (int __name, char *__buf, size_t __len,
size_t __buflen) throw ();
extern size_t __confstr_alias (int __name, char *__buf, size_t __len) throw () __asm__ ("" "confstr")
;
extern size_t __confstr_chk_warn (int __name, char *__buf, size_t __len, size_t __buflen) throw () __asm__ ("" "__confstr_chk")
__attribute__((__warning__ ("confstr called with bigger length than size of destination " "buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__leaf__)) confstr (int __name, char *__buf, size_t __len) throw ()
;
extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen)
throw () __attribute__ ((__warn_unused_result__));
extern int __getgroups_alias (int __size, __gid_t __list[]) throw () __asm__ ("" "getgroups")
__attribute__ ((__warn_unused_result__));
extern int __getgroups_chk_warn (int __size, __gid_t __list[], size_t __listlen) throw () __asm__ ("" "__getgroups_chk")
__attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getgroups called with bigger group count than what " "can fit into destination buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) getgroups (int __size, __gid_t __list[]) throw ()
;
extern int __ttyname_r_chk (int __fd, char *__buf, size_t __buflen,
size_t __nreal) throw () __attribute__ ((__nonnull__ (2)));
extern int __ttyname_r_alias (int __fd, char *__buf, size_t __buflen) throw () __asm__ ("" "ttyname_r")
__attribute__ ((__nonnull__ (2)));
extern int __ttyname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__ttyname_r_chk")
__attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ttyname_r called with bigger buflen than " "size of destination buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) ttyname_r (int __fd, char *__buf, size_t __buflen) throw ()
;
extern int __getlogin_r_chk (char *__buf, size_t __buflen, size_t __nreal)
__attribute__ ((__nonnull__ (1)));
extern int __getlogin_r_alias (char *__buf, size_t __buflen) __asm__ ("" "getlogin_r")
__attribute__ ((__nonnull__ (1)));
extern int __getlogin_r_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__getlogin_r_chk")
__attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("getlogin_r called with bigger buflen than " "size of destination buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
getlogin_r (char *__buf, size_t __buflen)
;
extern int __gethostname_chk (char *__buf, size_t __buflen, size_t __nreal)
throw () __attribute__ ((__nonnull__ (1)));
extern int __gethostname_alias (char *__buf, size_t __buflen) throw () __asm__ ("" "gethostname")
__attribute__ ((__nonnull__ (1)));
extern int __gethostname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__gethostname_chk")
__attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("gethostname called with bigger buflen than " "size of destination buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) gethostname (char *__buf, size_t __buflen) throw ()
;
extern int __getdomainname_chk (char *__buf, size_t __buflen, size_t __nreal)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int __getdomainname_alias (char *__buf, size_t __buflen) throw () __asm__ ("" "getdomainname")
__attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int __getdomainname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__getdomainname_chk")
__attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getdomainname called with bigger " "buflen than size of destination " "buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) getdomainname (char *__buf, size_t __buflen) throw ()
;
}
extern "C" {
typedef enum
{
P_ALL,
P_PID,
P_PGID
} idtype_t;
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;
};
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;
extern size_t __ctype_get_mb_cur_max (void) throw () __attribute__ ((__warn_unused_result__));
extern double atof (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int atoi (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern long int atol (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
__extension__ extern long long int atoll (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
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)));
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 __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) atoi (const char *__nptr) throw ()
;
extern __attribute__ ((__gnu_inline__)) long int
__attribute__ ((__leaf__)) atol (const char *__nptr) throw ()
;
__extension__ extern __attribute__ ((__gnu_inline__)) long long int
__attribute__ ((__leaf__)) atoll (const char *__nptr) throw ()
;
extern char *l64a (long int __n) throw () __attribute__ ((__warn_unused_result__));
extern long int a64l (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
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 __mode_t mode_t;
typedef __nlink_t nlink_t;
typedef __id_t id_t;
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;
typedef __key_t key_t;
typedef __suseconds_t suseconds_t;
typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));
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__)));
typedef int __sig_atomic_t;
typedef struct
{
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
} __sigset_t;
typedef __sigset_t sigset_t;
typedef long int __fd_mask;
typedef struct
{
__fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
} fd_set;
typedef __fd_mask fd_mask;
extern "C" {
extern int select (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
struct timeval *__restrict __timeout);
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);
extern long int __fdelt_chk (long int __d);
extern long int __fdelt_warn (long int __d)
__attribute__((__warning__ ("bit outside of fd_set selected")));
}
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 __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned int
__attribute__ ((__leaf__)) gnu_dev_major (unsigned long long int __dev) throw ()
;
__extension__ extern __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned int
__attribute__ ((__leaf__)) gnu_dev_minor (unsigned long long int __dev) throw ()
;
__extension__ extern __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned long long int
__attribute__ ((__leaf__)) gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw ()
;
}
typedef __blksize_t blksize_t;
typedef __blkcnt_t blkcnt_t;
typedef __fsblkcnt_t fsblkcnt_t;
typedef __fsfilcnt_t fsfilcnt_t;
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;
}
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__)) __attribute__ ((__warn_unused_result__));
extern void *calloc (size_t __nmemb, size_t __size)
throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
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 ();
extern "C" {
extern void *alloca (size_t __size) throw ();
}
extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern void *aligned_alloc (size_t __alignment, size_t __size)
throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) __attribute__ ((__warn_unused_result__));
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))) __attribute__ ((__warn_unused_result__));
extern char *secure_getenv (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
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 ();
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int mkstemps64 (char *__template, int __suffixlen)
__attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int mkostemps (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int system (const char *__command) __attribute__ ((__warn_unused_result__));
extern char *canonicalize_file_name (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern char *realpath (const char *__restrict __name,
char *__restrict __resolved) throw () __attribute__ ((__warn_unused_result__));
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))) __attribute__ ((__warn_unused_result__));
extern __attribute__ ((__gnu_inline__)) void *
bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size,
__compar_fn_t __compar)
;
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__)) __attribute__ ((__warn_unused_result__));
extern long int labs (long int __x) throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
__extension__ extern long long int llabs (long long int __x)
throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
extern div_t div (int __numer, int __denom)
throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
extern ldiv_t ldiv (long int __numer, long int __denom)
throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
__extension__ extern lldiv_t lldiv (long long int __numer,
long long int __denom)
throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
extern char *gcvt (double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));
extern char *qecvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
extern char *qfcvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));
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))) __attribute__ ((__warn_unused_result__));
extern int getsubopt (char **__restrict __optionp,
char *const *__restrict __tokens,
char **__restrict __valuep)
throw () __attribute__ ((__nonnull__ (1, 2, 3))) __attribute__ ((__warn_unused_result__));
extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1)));
extern int posix_openpt (int __oflag) __attribute__ ((__warn_unused_result__));
extern int grantpt (int __fd) throw ();
extern int unlockpt (int __fd) throw ();
extern char *ptsname (int __fd) throw () __attribute__ ((__warn_unused_result__));
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)));
extern __attribute__ ((__gnu_inline__)) double
__attribute__ ((__leaf__)) atof (const char *__nptr) throw ()
;
extern char *__realpath_chk (const char *__restrict __name,
char *__restrict __resolved,
size_t __resolvedlen) throw () __attribute__ ((__warn_unused_result__));
extern char *__realpath_alias (const char *__restrict __name, char *__restrict __resolved) throw () __asm__ ("" "realpath")
__attribute__ ((__warn_unused_result__));
extern char *__realpath_chk_warn (const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen) throw () __asm__ ("" "__realpath_chk")
__attribute__ ((__warn_unused_result__))
__attribute__((__warning__ ("second argument of realpath must be either NULL or at " "least PATH_MAX bytes long buffer")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
__attribute__ ((__leaf__)) realpath (const char *__restrict __name, char *__restrict __resolved) throw ()
;
extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen,
size_t __nreal) throw () __attribute__ ((__nonnull__ (2)));
extern int __ptsname_r_alias (int __fd, char *__buf, size_t __buflen) throw () __asm__ ("" "ptsname_r")
__attribute__ ((__nonnull__ (2)));
extern int __ptsname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__ptsname_r_chk")
__attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ptsname_r called with buflen bigger than " "size of buf")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) ptsname_r (int __fd, char *__buf, size_t __buflen) throw ()
;
extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen)
throw () __attribute__ ((__warn_unused_result__));
extern int __wctomb_alias (char *__s, wchar_t __wchar) throw () __asm__ ("" "wctomb")
__attribute__ ((__warn_unused_result__));
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) int
__attribute__ ((__leaf__)) wctomb (char *__s, wchar_t __wchar) throw ()
;
extern size_t __mbstowcs_chk (wchar_t *__restrict __dst,
const char *__restrict __src,
size_t __len, size_t __dstlen) throw ();
extern size_t __mbstowcs_alias (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len) throw () __asm__ ("" "mbstowcs")
;
extern size_t __mbstowcs_chk_warn (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len, size_t __dstlen) throw () __asm__ ("" "__mbstowcs_chk")
__attribute__((__warning__ ("mbstowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__leaf__)) mbstowcs (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len) throw ()
;
extern size_t __wcstombs_chk (char *__restrict __dst,
const wchar_t *__restrict __src,
size_t __len, size_t __dstlen) throw ();
extern size_t __wcstombs_alias (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len) throw () __asm__ ("" "wcstombs")
;
extern size_t __wcstombs_chk_warn (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len, size_t __dstlen) throw () __asm__ ("" "__wcstombs_chk")
__attribute__((__warning__ ("wcstombs called with dst buffer smaller than len")));
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__leaf__)) wcstombs (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len) throw ()
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::div_t;
using ::ldiv_t;
using ::abort;
using ::abs;
using ::atexit;
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 ::rand;
using ::realloc;
using ::srand;
using ::strtod;
using ::strtol;
using ::strtoul;
using ::system;
using ::wcstombs;
using ::wctomb;
long
abs(long __i) ;
ldiv_t
div(long __i, long __j) ;
long long
abs(long long __x) ;
__int128
abs(__int128 __x) ;
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
using ::lldiv_t;
using ::_Exit;
using ::llabs;
lldiv_t
div(long long __n, long long __d)
;
using ::lldiv;
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;
}
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;
}
namespace boost{
template <bool x> struct STATIC_ASSERTION_FAILURE;
template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
template<int x> struct static_assert_test{};
}
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
1 > 0
) == 0 ? false : true) >)> boost_static_assert_typedef_29 __attribute__((unused))
;
namespace boost
{
template<class T> void checked_delete(T * x)
;
template<class T> void checked_array_delete(T * x)
;
template<class T> struct checked_deleter
{
typedef void result_type;
typedef T * argument_type;
void operator()(T * x) const
;
};
template<class T> struct checked_array_deleter
{
typedef void result_type;
typedef T * argument_type;
void operator()(T * x) const
;
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _T1, typename _T2>
void
_Construct(_T1* __p, const _T2& __value)
;
template<typename _Tp>
void
_Destroy(_Tp* __pointer)
;
template<bool>
struct _Destroy_aux
{
template<typename _ForwardIterator>
static void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
;
};
template<>
struct _Destroy_aux<true>
{
template<typename _ForwardIterator>
static void
__destroy(_ForwardIterator, _ForwardIterator) ;
};
template<typename _ForwardIterator>
void
_Destroy(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Allocator>
void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp>
void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
;
}
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)
;
};
template<>
struct __uninitialized_copy<true>
{
template<typename _InputIterator, typename _ForwardIterator>
static _ForwardIterator
__uninit_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
;
};
template<typename _InputIterator, typename _ForwardIterator>
_ForwardIterator
uninitialized_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
;
template<bool _TrivialValueType>
struct __uninitialized_fill
{
template<typename _ForwardIterator, typename _Tp>
static void
__uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x)
;
};
template<>
struct __uninitialized_fill<true>
{
template<typename _ForwardIterator, typename _Tp>
static void
__uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x)
;
};
template<typename _ForwardIterator, typename _Tp>
void
uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x)
;
template<bool _TrivialValueType>
struct __uninitialized_fill_n
{
template<typename _ForwardIterator, typename _Size, typename _Tp>
static _ForwardIterator
__uninit_fill_n(_ForwardIterator __first, _Size __n,
const _Tp& __x)
;
};
template<>
struct __uninitialized_fill_n<true>
{
template<typename _ForwardIterator, typename _Size, typename _Tp>
static _ForwardIterator
__uninit_fill_n(_ForwardIterator __first, _Size __n,
const _Tp& __x)
;
};
template<typename _ForwardIterator, typename _Size, typename _Tp>
_ForwardIterator
uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
;
template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
_ForwardIterator
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, allocator<_Tp>&)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_move_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_move_if_noexcept_a(_InputIterator __first,
_InputIterator __last,
_ForwardIterator __result,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp, typename _Allocator>
void
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x, _Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp, typename _Tp2>
void
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x, allocator<_Tp2>&)
;
template<typename _ForwardIterator, typename _Size, typename _Tp,
typename _Allocator>
_ForwardIterator
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
const _Tp& __x, _Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Size, typename _Tp,
typename _Tp2>
_ForwardIterator
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
const _Tp& __x, allocator<_Tp2>&)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _ForwardIterator, typename _Allocator>
_ForwardIterator
__uninitialized_copy_move(_InputIterator1 __first1,
_InputIterator1 __last1,
_InputIterator2 __first2,
_InputIterator2 __last2,
_ForwardIterator __result,
_Allocator& __alloc)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _ForwardIterator, typename _Allocator>
_ForwardIterator
__uninitialized_move_copy(_InputIterator1 __first1,
_InputIterator1 __last1,
_InputIterator2 __first2,
_InputIterator2 __last2,
_ForwardIterator __result,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
const _Tp& __x, _InputIterator __first,
_InputIterator __last, _Allocator& __alloc)
;
template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
typename _Allocator>
void
__uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2,
_ForwardIterator __last2, const _Tp& __x,
_Allocator& __alloc)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp>
pair<_Tp*, ptrdiff_t>
get_temporary_buffer(ptrdiff_t __len)
;
template<typename _Tp>
void
return_temporary_buffer(_Tp* __p)
;
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
;
size_type
requested_size() const
;
iterator
begin()
;
iterator
end()
;
_Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
~_Temporary_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)
;
};
template<>
struct __uninitialized_construct_buf_dispatch<true>
{
template<typename _Pointer, typename _ForwardIterator>
static void
__ucr(_Pointer, _Pointer, _ForwardIterator) ;
};
template<typename _Pointer, typename _ForwardIterator>
void
__uninitialized_construct_buf(_Pointer __first, _Pointer __last,
_ForwardIterator __seed)
;
}
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) ;
raw_storage_iterator&
operator*() ;
raw_storage_iterator&
operator=(const _Tp& __element)
;
raw_storage_iterator<_OutputIterator, _Tp>&
operator++()
;
raw_storage_iterator<_OutputIterator, _Tp>
operator++(int)
;
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp1>
struct auto_ptr_ref
{
_Tp1* _M_ptr;
explicit
auto_ptr_ref(_Tp1* __p) ;
} ;
template<typename _Tp>
class auto_ptr
{
private:
_Tp* _M_ptr;
public:
typedef _Tp element_type;
explicit
auto_ptr(element_type* __p = 0) throw() ;
auto_ptr(auto_ptr& __a) throw() ;
template<typename _Tp1>
auto_ptr(auto_ptr<_Tp1>& __a) throw() ;
auto_ptr&
operator=(auto_ptr& __a) throw()
;
template<typename _Tp1>
auto_ptr&
operator=(auto_ptr<_Tp1>& __a) throw()
;
~auto_ptr() ;
element_type&
operator*() const throw()
;
element_type*
operator->() const throw()
;
element_type*
get() const throw() ;
element_type*
release() throw()
;
void
reset(element_type* __p = 0) throw()
;
auto_ptr(auto_ptr_ref<element_type> __ref) throw() ;
auto_ptr&
operator=(auto_ptr_ref<element_type> __ref) throw()
;
template<typename _Tp1>
operator auto_ptr_ref<_Tp1>() throw()
;
template<typename _Tp1>
operator auto_ptr<_Tp1>() throw()
;
} ;
template<>
class auto_ptr<void>
{
public:
typedef void element_type;
} ;
}
namespace boost
{
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 )
;
explicit scoped_ptr( std::auto_ptr<T> p )
;
~scoped_ptr()
;
void reset(T * p = 0)
;
T & operator*() const
;
T * operator->() const
;
T * get() const
;
typedef element_type * this_type::*unspecified_bool_type;
operator unspecified_bool_type() const
;
bool operator! () const
;
void swap(scoped_ptr & b)
;
};
template<class T> void swap(scoped_ptr<T> & a, scoped_ptr<T> & b)
;
template<class T> T * get_pointer(scoped_ptr<T> const & p)
;
}
namespace mpl_ { namespace aux {} }
namespace boost { namespace mpl { using namespace mpl_;
namespace aux { using namespace mpl_::aux; }
}}
namespace mpl_ {
template< int N > struct int_;
}
namespace boost { namespace mpl { using ::mpl_::int_; } }
namespace mpl_ {
struct integral_c_tag {
static const
int value = 0; };
}
namespace boost { namespace mpl { using ::mpl_::integral_c_tag; } }
namespace mpl_ {
template< int N >
struct int_
{
static const
int value = N;
typedef int_ type;
typedef int value_type;
typedef integral_c_tag tag;
typedef mpl_::int_< static_cast<int>((value + 1)) > next;
typedef mpl_::int_< static_cast<int>((value - 1)) > prior;
operator int() const ;
};
template< int N >
int const mpl_::int_< N >::value;
}
namespace boost { namespace mpl { namespace aux {
template< typename F > struct template_arity;
}}}
namespace boost {
namespace detail{
template <class T>
struct remove_rvalue_ref
{
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; };
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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;
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);
locale() throw();
locale(const locale& __other) throw();
explicit
locale(const char* __s);
locale(const locale& __base, const char* __s, category __cat);
locale(const locale& __base, const locale& __add, category __cat);
template<typename _Facet>
locale(const locale& __other, _Facet* __f);
~locale() throw();
const locale&
operator=(const locale& __other) throw();
template<typename _Facet>
locale
combine(const locale& __other) const;
__attribute ((__abi_tag__ ("cxx11")))
string
name() const;
bool
operator==(const locale& __other) const throw();
bool
operator!=(const locale& __other) const throw()
;
template<typename _Char, typename _Traits, typename _Alloc>
bool
operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
const basic_string<_Char, _Traits, _Alloc>& __s2) const;
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;
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);
static const id* const _S_twinned_facets[];
};
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:
explicit
facet(size_t __refs = 0) throw()
;
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()
;
void
_M_remove_reference() const throw()
;
facet(const facet&);
facet&
operator=(const facet&);
class __shim;
const facet* _M_sso_shim(const id*) const;
const facet* _M_cow_shim(const id*) const;
};
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()
;
void
_M_remove_reference() throw()
;
_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()
;
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)
;
template<typename _Facet>
void
_M_init_facet_unchecked(_Facet* __facet)
;
void
_M_install_cache(const facet*, size_t);
void _M_init_extra(facet**);
void _M_init_extra(void*, void*, const char*, const char*);
};
template<typename _CharT>
class __cxx11:: 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;
explicit
collate(size_t __refs = 0)
;
explicit
collate(__c_locale __cloc, size_t __refs = 0)
;
int
compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const
;
string_type
transform(const _CharT* __lo, const _CharT* __hi) const
;
long
hash(const _CharT* __lo, const _CharT* __hi) const
;
int
_M_compare(const _CharT*, const _CharT*) const throw();
size_t
_M_transform(_CharT*, const _CharT*, size_t) const throw();
protected:
virtual
~collate()
;
virtual int
do_compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const;
virtual string_type
do_transform(const _CharT* __lo, const _CharT* __hi) const;
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 __cxx11:: 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)
;
protected:
virtual
~collate_byname() ;
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
bool
has_facet(const locale& __loc) throw()
;
template<typename _Facet>
const _Facet&
use_facet(const locale& __loc)
;
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&);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
struct __cow_string
{
union {
const char* _M_p;
char _M_bytes[sizeof(const char*)];
};
__cow_string();
__cow_string(const std::string&);
__cow_string(const char*, size_t);
__cow_string(const __cow_string&) throw();
__cow_string& operator=(const __cow_string&) throw();
~__cow_string();
};
typedef basic_string<char> __sso_string;
class logic_error : public exception
{
__cow_string _M_msg;
public:
explicit
logic_error(const string& __arg);
logic_error(const logic_error&) throw();
logic_error& operator=(const logic_error&) throw();
virtual ~logic_error() throw();
virtual const char*
what() const throw();
};
class domain_error : public logic_error
{
public:
explicit domain_error(const string& __arg);
virtual ~domain_error() throw();
};
class invalid_argument : public logic_error
{
public:
explicit invalid_argument(const string& __arg);
virtual ~invalid_argument() throw();
};
class length_error : public logic_error
{
public:
explicit length_error(const string& __arg);
virtual ~length_error() throw();
};
class out_of_range : public logic_error
{
public:
explicit out_of_range(const string& __arg);
virtual ~out_of_range() throw();
};
class runtime_error : public exception
{
__cow_string _M_msg;
public:
explicit
runtime_error(const string& __arg);
runtime_error(const runtime_error&) throw();
runtime_error& operator=(const runtime_error&) throw();
virtual ~runtime_error() throw();
virtual const char*
what() const throw();
};
class range_error : public runtime_error
{
public:
explicit range_error(const string& __arg);
virtual ~range_error() throw();
};
class overflow_error : public runtime_error
{
public:
explicit overflow_error(const string& __arg);
virtual ~overflow_error() throw();
};
class underflow_error : public runtime_error
{
public:
explicit underflow_error(const string& __arg);
virtual ~underflow_error() throw();
};
}
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,
_S_ios_fmtflags_max = 0x7fffffff,
_S_ios_fmtflags_min = ~0x7fffffff
};
_Ios_Fmtflags
operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
;
_Ios_Fmtflags
operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
;
_Ios_Fmtflags
operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
;
_Ios_Fmtflags
operator~(_Ios_Fmtflags __a)
;
const _Ios_Fmtflags&
operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
;
const _Ios_Fmtflags&
operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
;
const _Ios_Fmtflags&
operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __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,
_S_ios_openmode_max = 0x7fffffff,
_S_ios_openmode_min = ~0x7fffffff
};
_Ios_Openmode
operator&(_Ios_Openmode __a, _Ios_Openmode __b)
;
_Ios_Openmode
operator|(_Ios_Openmode __a, _Ios_Openmode __b)
;
_Ios_Openmode
operator^(_Ios_Openmode __a, _Ios_Openmode __b)
;
_Ios_Openmode
operator~(_Ios_Openmode __a)
;
const _Ios_Openmode&
operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
;
const _Ios_Openmode&
operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
;
const _Ios_Openmode&
operator^=(_Ios_Openmode& __a, _Ios_Openmode __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,
_S_ios_iostate_max = 0x7fffffff,
_S_ios_iostate_min = ~0x7fffffff
};
_Ios_Iostate
operator&(_Ios_Iostate __a, _Ios_Iostate __b)
;
_Ios_Iostate
operator|(_Ios_Iostate __a, _Ios_Iostate __b)
;
_Ios_Iostate
operator^(_Ios_Iostate __a, _Ios_Iostate __b)
;
_Ios_Iostate
operator~(_Ios_Iostate __a)
;
const _Ios_Iostate&
operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
;
const _Ios_Iostate&
operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
;
const _Ios_Iostate&
operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
;
enum _Ios_Seekdir
{
_S_beg = 0,
_S_cur = 1,
_S_end = 2,
_S_ios_seekdir_end = 1L << 16
};
class ios_base
{
struct system_error : std::runtime_error
{
struct error_code
{
error_code() ;
private:
int _M_value;
const void* _M_cat;
} _M_code;
};
public:
class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error
{
public:
explicit
failure(const string& __str);
virtual
~failure() throw();
virtual const char*
what() const throw();
};
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;
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;
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;
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;
enum event
{
erase_event,
imbue_event,
copyfmt_event
};
typedef void (*event_callback) (event __e, ios_base& __b, int __i);
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) ;
void
_M_add_reference() ;
int
_M_remove_reference()
;
};
_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() ;
};
_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
;
fmtflags
flags(fmtflags __fmtfl)
;
fmtflags
setf(fmtflags __fmtfl)
;
fmtflags
setf(fmtflags __fmtfl, fmtflags __mask)
;
void
unsetf(fmtflags __mask)
;
streamsize
precision() const
;
streamsize
precision(streamsize __prec)
;
streamsize
width() const
;
streamsize
width(streamsize __wide)
;
static bool
sync_with_stdio(bool __sync = true);
locale
imbue(const locale& __loc) throw();
locale
getloc() const
;
const locale&
_M_getloc() const
;
static int
xalloc() throw();
long&
iword(int __ix)
;
void*&
pword(int __ix)
;
virtual ~ios_base();
protected:
ios_base() throw ();
private:
ios_base(const ios_base&);
ios_base&
operator=(const ios_base&);
};
ios_base&
boolalpha(ios_base& __base)
;
ios_base&
noboolalpha(ios_base& __base)
;
ios_base&
showbase(ios_base& __base)
;
ios_base&
noshowbase(ios_base& __base)
;
ios_base&
showpoint(ios_base& __base)
;
ios_base&
noshowpoint(ios_base& __base)
;
ios_base&
showpos(ios_base& __base)
;
ios_base&
noshowpos(ios_base& __base)
;
ios_base&
skipws(ios_base& __base)
;
ios_base&
noskipws(ios_base& __base)
;
ios_base&
uppercase(ios_base& __base)
;
ios_base&
nouppercase(ios_base& __base)
;
ios_base&
unitbuf(ios_base& __base)
;
ios_base&
nounitbuf(ios_base& __base)
;
ios_base&
internal(ios_base& __base)
;
ios_base&
left(ios_base& __base)
;
ios_base&
right(ios_base& __base)
;
ios_base&
dec(ios_base& __base)
;
ios_base&
hex(ios_base& __base)
;
ios_base&
oct(ios_base& __base)
;
ios_base&
fixed(ios_base& __base)
;
ios_base&
scientific(ios_base& __base)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
basic_streambuf<_CharT, _Traits>*, bool&);
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()
;
locale
pubimbue(const locale& __loc)
;
locale
getloc() const
;
basic_streambuf*
pubsetbuf(char_type* __s, streamsize __n)
;
pos_type
pubseekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out)
;
pos_type
pubseekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out)
;
int
pubsync() ;
streamsize
in_avail()
;
int_type
snextc()
;
int_type
sbumpc()
;
int_type
sgetc()
;
streamsize
sgetn(char_type* __s, streamsize __n)
;
int_type
sputbackc(char_type __c)
;
int_type
sungetc()
;
int_type
sputc(char_type __c)
;
streamsize
sputn(const char_type* __s, streamsize __n)
;
protected:
basic_streambuf()
;
char_type*
eback() const ;
char_type*
gptr() const ;
char_type*
egptr() const ;
void
gbump(int __n) ;
void
setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
;
char_type*
pbase() const ;
char_type*
pptr() const ;
char_type*
epptr() const ;
void
pbump(int __n) ;
void
setp(char_type* __pbeg, char_type* __pend)
;
virtual void
imbue(const locale& __loc)
;
virtual basic_streambuf<char_type,_Traits>*
setbuf(char_type*, streamsize)
;
virtual pos_type
seekoff(off_type, ios_base::seekdir,
ios_base::openmode = ios_base::in | ios_base::out)
;
virtual pos_type
seekpos(pos_type,
ios_base::openmode = ios_base::in | ios_base::out)
;
virtual int
sync() ;
virtual streamsize
showmanyc() ;
virtual streamsize
xsgetn(char_type* __s, streamsize __n);
virtual int_type
underflow()
;
virtual int_type
uflow()
;
virtual int_type
pbackfail(int_type __c = traits_type::eof())
;
virtual streamsize
xsputn(const char_type* __s, streamsize __n);
virtual int_type
overflow(int_type __c = traits_type::eof())
;
public:
void
stossc()
;
void
__safe_gbump(streamsize __n) ;
void
__safe_pbump(streamsize __n) ;
private:
basic_streambuf(const basic_streambuf&);
basic_streambuf&
operator=(const basic_streambuf&);
};
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);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout,
bool& __ineof)
;
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout)
;
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&);
}
typedef unsigned long int wctype_t;
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 ();
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 ();
}
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 ();
}
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;
}
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;
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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:
istreambuf_iterator() throw() ;
istreambuf_iterator(istream_type& __s) throw() ;
istreambuf_iterator(streambuf_type* __s) throw() ;
char_type
operator*() const
;
istreambuf_iterator&
operator++()
;
istreambuf_iterator
operator++(int)
;
bool
equal(const istreambuf_iterator& __b) const
;
private:
int_type
_M_get() const
;
bool
_M_at_eof() const
;
};
template<typename _CharT, typename _Traits>
bool
operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
;
template<typename _CharT, typename _Traits>
bool
operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __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) throw() ;
ostreambuf_iterator(streambuf_type* __s) throw() ;
ostreambuf_iterator&
operator=(_CharT __c)
;
ostreambuf_iterator&
operator*()
;
ostreambuf_iterator&
operator++(int)
;
ostreambuf_iterator&
operator++()
;
bool
failed() const throw()
;
ostreambuf_iterator&
_M_put(const _CharT* __ws, streamsize __len)
;
};
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)
;
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)
;
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)
;
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)
;
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)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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>
ostreambuf_iterator<_CharT>
__write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
;
template<typename _CharT, typename _OutIter>
_OutIter
__write(_OutIter __s, const _CharT* __ws, int __len)
;
template<typename _CharT>
class __ctype_abstract_base : public locale::facet, public ctype_base
{
public:
typedef _CharT char_type;
bool
is(mask __m, char_type __c) const
;
const char_type*
is(const char_type *__lo, const char_type *__hi, mask *__vec) const
;
const char_type*
scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
;
const char_type*
scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
;
char_type
toupper(char_type __c) const
;
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
;
char_type
tolower(char_type __c) const
;
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
;
char_type
widen(char __c) const
;
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
;
char
narrow(char_type __c, char __dfault) const
;
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
;
protected:
explicit
__ctype_abstract_base(size_t __refs = 0) ;
virtual
~__ctype_abstract_base() ;
virtual bool
do_is(mask __m, char_type __c) const = 0;
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi,
mask* __vec) const = 0;
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
virtual char_type
do_toupper(char_type __c) const = 0;
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const = 0;
virtual char_type
do_tolower(char_type __c) const = 0;
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const = 0;
virtual char_type
do_widen(char __c) const = 0;
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
virtual char
do_narrow(char_type __c, char __dfault) const = 0;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const = 0;
};
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) ;
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;
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);
explicit
ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
explicit
ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
size_t __refs = 0);
inline bool
is(mask __m, char __c) const;
inline const char*
is(const char* __lo, const char* __hi, mask* __vec) const;
inline const char*
scan_is(mask __m, const char* __lo, const char* __hi) const;
inline const char*
scan_not(mask __m, const char* __lo, const char* __hi) const;
char_type
toupper(char_type __c) const
;
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
;
char_type
tolower(char_type __c) const
;
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
;
char_type
widen(char __c) const
;
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
;
char
narrow(char_type __c, char __dfault) const
;
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
;
const mask*
table() const throw()
;
static const mask*
classic_table() throw();
protected:
virtual
~ctype();
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* __to) const
;
virtual char
do_narrow(char_type __c, char __dfault) const
;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
;
private:
void _M_narrow_init() const;
void _M_widen_init() const;
};
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;
explicit
ctype(size_t __refs = 0);
explicit
ctype(__c_locale __cloc, size_t __refs = 0);
protected:
__wmask_type
_M_convert_to_wmask(const mask __m) const throw();
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* __to) const;
virtual char
do_narrow(char_type __c, char __dfault) const;
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();
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
}
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)
;
~__numpunct_cache();
void
_M_cache(const locale& __loc);
private:
__numpunct_cache&
operator=(const __numpunct_cache&);
explicit
__numpunct_cache(const __numpunct_cache&);
};
namespace __cxx11 {
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)
;
explicit
numpunct(__cache_type* __cache, size_t __refs = 0)
;
explicit
numpunct(__c_locale __cloc, size_t __refs = 0)
;
char_type
decimal_point() const
;
char_type
thousands_sep() const
;
string
grouping() const
;
string_type
truename() const
;
string_type
falsename() const
;
protected:
virtual
~numpunct();
virtual char_type
do_decimal_point() const
;
virtual char_type
do_thousands_sep() const
;
virtual string
do_grouping() const
;
virtual string_type
do_truename() const
;
virtual string_type
do_falsename() const
;
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)
;
protected:
virtual
~numpunct_byname() ;
};
}
template<typename _CharT, typename _InIter>
class num_get : public locale::facet
{
public:
typedef _CharT char_type;
typedef _InIter iter_type;
static locale::id id;
explicit
num_get(size_t __refs = 0) ;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, bool& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, float& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, double& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long double& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, void*& __v) const
;
protected:
virtual ~num_get() ;
__attribute ((__abi_tag__ ("cxx11")))
iter_type
_M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
string&) const;
template<typename _ValueT>
__attribute ((__abi_tag__ ("cxx11")))
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
;
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
;
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
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
;
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;
};
template<typename _CharT, typename _InIter>
locale::id num_get<_CharT, _InIter>::id;
template<typename _CharT, typename _OutIter>
class num_put : public locale::facet
{
public:
typedef _CharT char_type;
typedef _OutIter iter_type;
static locale::id id;
explicit
num_put(size_t __refs = 0) ;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
long double __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
const void* __v) const
;
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() ;;
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
;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
long long __v) const
;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long long __v) const
;
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>
bool
isspace(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isprint(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
iscntrl(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isupper(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
islower(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isalpha(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isdigit(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
ispunct(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isxdigit(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isalnum(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isgraph(_CharT __c, const locale& __loc)
;
template<typename _CharT>
_CharT
toupper(_CharT __c, const locale& __loc)
;
template<typename _CharT>
_CharT
tolower(_CharT __c, const locale& __loc)
;
}
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
;
};
__attribute__ ((__pure__)) bool
__verify_grouping(const char* __grouping, size_t __grouping_size,
const string& __grouping_tmp) throw ();
template<typename _CharT, typename _ValueT>
int
__int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
ios_base::fmtflags __flags, bool __dec)
;
template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last)
;
extern template class __cxx11:: numpunct<char>;
extern template class __cxx11:: 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 __cxx11:: numpunct<wchar_t>;
extern template class __cxx11:: 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&);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
const _Facet&
__check_facet(const _Facet* __f)
;
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
;
bool
operator!() const
;
iostate
rdstate() const
;
void
clear(iostate __state = goodbit);
void
setstate(iostate __state)
;
void
_M_setstate(iostate __state)
;
bool
good() const
;
bool
eof() const
;
bool
fail() const
;
bool
bad() const
;
iostate
exceptions() const
;
void
exceptions(iostate __except)
;
explicit
basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
;
virtual
~basic_ios() ;
basic_ostream<_CharT, _Traits>*
tie() const
;
basic_ostream<_CharT, _Traits>*
tie(basic_ostream<_CharT, _Traits>* __tiestr)
;
basic_streambuf<_CharT, _Traits>*
rdbuf() const
;
basic_streambuf<_CharT, _Traits>*
rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
basic_ios&
copyfmt(const basic_ios& __rhs);
char_type
fill() const
;
char_type
fill(char_type __ch)
;
locale
imbue(const locale& __loc);
char
narrow(char_type __c, char __dfault) const
;
char_type
widen(char __c) const
;
protected:
basic_ios()
;
void
init(basic_streambuf<_CharT, _Traits>* __sb);
void
_M_cache_locale(const locale& __loc);
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
extern template class basic_ios<char>;
extern template class basic_ios<wchar_t>;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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;
explicit
basic_ostream(__streambuf_type* __sb)
;
virtual
~basic_ostream() ;
class sentry;
friend class sentry;
__ostream_type&
operator<<(__ostream_type& (*__pf)(__ostream_type&))
;
__ostream_type&
operator<<(__ios_type& (*__pf)(__ios_type&))
;
__ostream_type&
operator<<(ios_base& (*__pf) (ios_base&))
;
__ostream_type&
operator<<(long __n)
;
__ostream_type&
operator<<(unsigned long __n)
;
__ostream_type&
operator<<(bool __n)
;
__ostream_type&
operator<<(short __n);
__ostream_type&
operator<<(unsigned short __n)
;
__ostream_type&
operator<<(int __n);
__ostream_type&
operator<<(unsigned int __n)
;
__ostream_type&
operator<<(long long __n)
;
__ostream_type&
operator<<(unsigned long long __n)
;
__ostream_type&
operator<<(double __f)
;
__ostream_type&
operator<<(float __f)
;
__ostream_type&
operator<<(long double __f)
;
__ostream_type&
operator<<(const void* __p)
;
__ostream_type&
operator<<(__streambuf_type* __sb);
__ostream_type&
put(char_type __c);
void
_M_write(const char_type* __s, streamsize __n)
;
__ostream_type&
write(const char_type* __s, streamsize __n);
__ostream_type&
flush();
pos_type
tellp();
__ostream_type&
seekp(pos_type);
__ostream_type&
seekp(off_type, ios_base::seekdir);
protected:
basic_ostream()
;
template<typename _ValueT>
__ostream_type&
_M_insert(_ValueT __v);
};
template <typename _CharT, typename _Traits>
class basic_ostream<_CharT, _Traits>::sentry
{
bool _M_ok;
basic_ostream<_CharT, _Traits>& _M_os;
public:
explicit
sentry(basic_ostream<_CharT, _Traits>& __os);
~sentry()
;
operator bool() const
;
};
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
;
template <class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, char __c)
;
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
;
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
;
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
;
template<class _Traits>
basic_ostream<char, _Traits> &
operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
endl(basic_ostream<_CharT, _Traits>& __os)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
ends(basic_ostream<_CharT, _Traits>& __os)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
flush(basic_ostream<_CharT, _Traits>& __os)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
;
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*);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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)
;
virtual
~basic_istream()
;
class sentry;
friend class sentry;
__istream_type&
operator>>(__istream_type& (*__pf)(__istream_type&))
;
__istream_type&
operator>>(__ios_type& (*__pf)(__ios_type&))
;
__istream_type&
operator>>(ios_base& (*__pf)(ios_base&))
;
__istream_type&
operator>>(bool& __n)
;
__istream_type&
operator>>(short& __n);
__istream_type&
operator>>(unsigned short& __n)
;
__istream_type&
operator>>(int& __n);
__istream_type&
operator>>(unsigned int& __n)
;
__istream_type&
operator>>(long& __n)
;
__istream_type&
operator>>(unsigned long& __n)
;
__istream_type&
operator>>(long long& __n)
;
__istream_type&
operator>>(unsigned long long& __n)
;
__istream_type&
operator>>(float& __f)
;
__istream_type&
operator>>(double& __f)
;
__istream_type&
operator>>(long double& __f)
;
__istream_type&
operator>>(void*& __p)
;
__istream_type&
operator>>(__streambuf_type* __sb);
streamsize
gcount() const
;
int_type
get();
__istream_type&
get(char_type& __c);
__istream_type&
get(char_type* __s, streamsize __n, char_type __delim);
__istream_type&
get(char_type* __s, streamsize __n)
;
__istream_type&
get(__streambuf_type& __sb, char_type __delim);
__istream_type&
get(__streambuf_type& __sb)
;
__istream_type&
getline(char_type* __s, streamsize __n, char_type __delim);
__istream_type&
getline(char_type* __s, streamsize __n)
;
__istream_type&
ignore(streamsize __n, int_type __delim);
__istream_type&
ignore(streamsize __n);
__istream_type&
ignore();
int_type
peek();
__istream_type&
read(char_type* __s, streamsize __n);
streamsize
readsome(char_type* __s, streamsize __n);
__istream_type&
putback(char_type __c);
__istream_type&
unget();
int
sync();
pos_type
tellg();
__istream_type&
seekg(pos_type);
__istream_type&
seekg(off_type, ios_base::seekdir);
protected:
basic_istream()
;
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);
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;
explicit
sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
operator bool() const
;
};
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
;
template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
;
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>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
;
template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
;
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) ;
virtual
~basic_iostream() ;
protected:
basic_iostream() ;
};
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __is);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
;
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
;
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __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>;
}
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:
istream_iterator() ;
istream_iterator(istream_type& __s)
;
istream_iterator(const istream_iterator& __obj)
;
const _Tp&
operator*() const
;
const _Tp*
operator->() const ;
istream_iterator&
operator++()
;
istream_iterator
operator++(int)
;
bool
_M_equal(const istream_iterator& __x) const
;
private:
void
_M_read()
;
};
template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
bool
operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
;
template <class _Tp, class _CharT, class _Traits, class _Dist>
bool
operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
;
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) ;
ostream_iterator(ostream_type& __s, const _CharT* __c) ;
ostream_iterator(const ostream_iterator& __obj) ;
ostream_iterator&
operator=(const _Tp& __value)
;
ostream_iterator&
operator*()
;
ostream_iterator&
operator++()
;
ostream_iterator&
operator++(int)
;
};
}
namespace boost { namespace spirit {
namespace classic {
struct nil_t {};
}
}}
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_; } }
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 ;
};
template< bool C_ >
bool const bool_<C_>::value;
}
namespace mpl_ {
template< typename T, T N > struct integral_c;
}
namespace boost { namespace mpl { using ::mpl_::integral_c; } }
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;
typedef integral_c< T, static_cast<T>((value + 1)) > next;
typedef integral_c< T, static_cast<T>((value - 1)) > prior;
operator T() const ;
};
template< typename T, T N >
T const integral_c< T, N >::value;
}
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 ;
};
}
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;
}
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: };
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: };
}
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: };
}
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;
};
}
}
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: };
}
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: };
}
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: };
}
namespace boost {
template< typename T > struct is_rvalue_reference : public ::boost::integral_constant<bool,false> { public: };
}
namespace boost {
namespace type_traits {
typedef char yes_type;
struct no_type
{
char padding[8];
};
}
}
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;
};
}
}
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;
};
}
}
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;
}
}
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: };
}
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;
};
}
}
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< 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: };
}
namespace boost {
template< typename T > struct is_enum : public ::boost::integral_constant<bool,__is_enum(T)> { public: };
}
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; };
}
}
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< 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]; };
}
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: };
}
namespace boost {
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< U T::* > : public ::boost::integral_constant<bool,true> { public: };
template< typename T, typename U > struct is_member_pointer< U T::*const > : public ::boost::integral_constant<bool,true> { public: };
template< typename T, typename U > struct is_member_pointer< U T::*volatile > : public ::boost::integral_constant<bool,true> { public: };
template< typename T, typename U > struct is_member_pointer< U T::*const volatile > : public ::boost::integral_constant<bool,true> { public: };
}
namespace boost {
namespace detail {
template< typename T > struct is_pointer_helper
{
static const
bool value = false;
};
template< typename T > struct is_pointer_helper<T*> {
static const
bool value = true; };
template< typename T >
struct is_pointer_impl
{
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: };
}
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;
};
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;
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace rel_ops
{
template <class _Tp>
bool
operator!=(const _Tp& __x, const _Tp& __y)
;
template <class _Tp>
bool
operator>(const _Tp& __x, const _Tp& __y)
;
template <class _Tp>
bool
operator<=(const _Tp& __x, const _Tp& __y)
;
template <class _Tp>
bool
operator>=(const _Tp& __x, const _Tp& __y)
;
}
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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 _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 _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 _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 _BIter>
bool
next_permutation(_BIter, _BIter);
template<typename _BIter, typename _Compare>
bool
next_permutation(_BIter, _BIter, _Compare);
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 _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);
inline namespace _V2
{
template<typename _FIter>
_FIter
rotate(_FIter, _FIter, _FIter);
}
template<typename _FIter, typename _OIter>
_OIter
rotate_copy(_FIter, _FIter, _FIter, _OIter);
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&)
;
template<typename _Tp, size_t _Nm>
void
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
;
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);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _RandomAccessIterator, typename _Distance,
typename _Compare>
_Distance
__is_heap_until(_RandomAccessIterator __first, _Distance __n,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Distance>
bool
__is_heap(_RandomAccessIterator __first, _Distance __n)
;
template<typename _RandomAccessIterator, typename _Compare,
typename _Distance>
bool
__is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
;
template<typename _RandomAccessIterator>
bool
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
bool
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
typename _Compare>
void
__push_heap(_RandomAccessIterator __first,
_Distance __holeIndex, _Distance __topIndex, _Tp __value,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Distance,
typename _Tp, typename _Compare>
void
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
_Distance __len, _Tp __value, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_RandomAccessIterator __result, _Compare __comp)
;
template<typename _RandomAccessIterator>
void
pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
pop_heap(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Iterator, typename _Compare>
void
__move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
_Iterator __c, _Compare __comp)
;
template<typename _InputIterator, typename _Predicate>
_InputIterator
__find_if(_InputIterator __first, _InputIterator __last,
_Predicate __pred, input_iterator_tag)
;
template<typename _RandomAccessIterator, typename _Predicate>
_RandomAccessIterator
__find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Predicate __pred, random_access_iterator_tag)
;
template<typename _Iterator, typename _Predicate>
_Iterator
__find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
_InputIterator
__find_if_not(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
;
template<typename _InputIterator, typename _Predicate, typename _Distance>
_InputIterator
__find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
_ForwardIterator1
__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __predicate)
;
template<typename _ForwardIterator, typename _Integer,
typename _UnaryPredicate>
_ForwardIterator
__search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, _UnaryPredicate __unary_pred,
std::forward_iterator_tag)
;
template<typename _RandomAccessIter, typename _Integer,
typename _UnaryPredicate>
_RandomAccessIter
__search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
_Integer __count, _UnaryPredicate __unary_pred,
std::random_access_iterator_tag)
;
template<typename _ForwardIterator, typename _Integer,
typename _UnaryPredicate>
_ForwardIterator
__search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count,
_UnaryPredicate __unary_pred)
;
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)
;
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)
;
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator1
find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
_ForwardIterator1
find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __comp)
;
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
_OutputIterator
__remove_copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
;
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
_OutputIterator
remove_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, const _Tp& __value)
;
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
_OutputIterator
remove_copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__remove_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _ForwardIterator, typename _Tp>
_ForwardIterator
remove(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
remove_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
__adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
__unique(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
;
template<typename _ForwardIterator>
_ForwardIterator
unique(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
unique(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
;
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)
;
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)
;
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)
;
template<typename _BidirectionalIterator>
void
__reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
bidirectional_iterator_tag)
;
template<typename _RandomAccessIterator>
void
__reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag)
;
template<typename _BidirectionalIterator>
void
reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _OutputIterator>
_OutputIterator
reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
_OutputIterator __result)
;
template<typename _EuclideanRingElement>
_EuclideanRingElement
__gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
;
inline namespace _V2
{
template<typename _ForwardIterator>
_ForwardIterator
__rotate(_ForwardIterator __first,
_ForwardIterator __middle,
_ForwardIterator __last,
forward_iterator_tag)
;
template<typename _BidirectionalIterator>
_BidirectionalIterator
__rotate(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
bidirectional_iterator_tag)
;
template<typename _RandomAccessIterator>
_RandomAccessIterator
__rotate(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
random_access_iterator_tag)
;
template<typename _ForwardIterator>
_ForwardIterator
rotate(_ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last)
;
}
template<typename _ForwardIterator, typename _OutputIterator>
_OutputIterator
rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last, _OutputIterator __result)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, forward_iterator_tag)
;
template<typename _BidirectionalIterator, typename _Predicate>
_BidirectionalIterator
__partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
_Predicate __pred, bidirectional_iterator_tag)
;
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)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__stable_partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
stable_partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__heap_select(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _InputIterator, typename _RandomAccessIterator,
typename _Compare>
_RandomAccessIterator
__partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last,
_Compare __comp)
;
template<typename _InputIterator, typename _RandomAccessIterator>
_RandomAccessIterator
partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last)
;
template<typename _InputIterator, typename _RandomAccessIterator,
typename _Compare>
_RandomAccessIterator
partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__unguarded_linear_insert(_RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__unguarded_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
enum { _S_threshold = 16 };
template<typename _RandomAccessIterator, typename _Compare>
void
__final_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
_RandomAccessIterator
__unguarded_partition(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_RandomAccessIterator __pivot, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
_RandomAccessIterator
__unguarded_partition_pivot(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Size, typename _Compare>
void
__introsort_loop(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Size __depth_limit, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Size, typename _Compare>
void
__introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Size __depth_limit,
_Compare __comp)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
__upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp>
_ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp,
typename _CompareItTp, typename _CompareTpIt>
pair<_ForwardIterator, _ForwardIterator>
__equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val,
_CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
;
template<typename _ForwardIterator, typename _Tp>
pair<_ForwardIterator, _ForwardIterator>
equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
pair<_ForwardIterator, _ForwardIterator>
equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp>
bool
binary_search(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
bool
binary_search(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
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)
;
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)
;
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)
;
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)
;
template<typename _BidirectionalIterator, typename _Distance,
typename _Compare>
void
__merge_without_buffer(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Compare __comp)
;
template<typename _BidirectionalIterator, typename _Compare>
void
__inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Compare __comp)
;
template<typename _BidirectionalIterator>
void
inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _Compare>
void
inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Compare __comp)
;
template<typename _InputIterator, typename _OutputIterator,
typename _Compare>
_OutputIterator
__move_merge(_InputIterator __first1, _InputIterator __last1,
_InputIterator __first2, _InputIterator __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
typename _Distance, typename _Compare>
void
__merge_sort_loop(_RandomAccessIterator1 __first,
_RandomAccessIterator1 __last,
_RandomAccessIterator2 __result, _Distance __step_size,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Distance,
typename _Compare>
void
__chunk_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Distance __chunk_size, _Compare __comp)
;
enum { _S_chunk_size = 7 };
template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
void
__merge_sort_with_buffer(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Pointer,
typename _Distance, typename _Compare>
void
__stable_sort_adaptive(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__inplace_stable_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _Compare>
bool
__includes(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2>
bool
includes(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _Compare>
bool
includes(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_Compare __comp)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
__next_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
;
template<typename _BidirectionalIterator>
bool
next_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
next_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
__prev_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
;
template<typename _BidirectionalIterator>
bool
prev_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
prev_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
;
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)
;
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
_OutputIterator
replace_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result,
const _Tp& __old_value, const _Tp& __new_value)
;
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)
;
template<typename _InputIterator, typename _Predicate>
typename iterator_traits<_InputIterator>::difference_type
__count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _InputIterator, typename _Function>
_Function
for_each(_InputIterator __first, _InputIterator __last, _Function __f)
;
template<typename _InputIterator, typename _Tp>
_InputIterator
find(_InputIterator __first, _InputIterator __last,
const _Tp& __val)
;
template<typename _InputIterator, typename _Predicate>
_InputIterator
find_if(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
;
template<typename _InputIterator, typename _ForwardIterator>
_InputIterator
find_first_of(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2, _ForwardIterator __last2)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _BinaryPredicate>
_InputIterator
find_first_of(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2, _ForwardIterator __last2,
_BinaryPredicate __comp)
;
template<typename _ForwardIterator>
_ForwardIterator
adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
;
template<typename _InputIterator, typename _Tp>
typename iterator_traits<_InputIterator>::difference_type
count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
;
template<typename _InputIterator, typename _Predicate>
typename iterator_traits<_InputIterator>::difference_type
count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator1
search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
_ForwardIterator1
search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __predicate)
;
template<typename _ForwardIterator, typename _Integer, typename _Tp>
_ForwardIterator
search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, const _Tp& __val)
;
template<typename _ForwardIterator, typename _Integer, typename _Tp,
typename _BinaryPredicate>
_ForwardIterator
search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, const _Tp& __val,
_BinaryPredicate __binary_pred)
;
template<typename _InputIterator, typename _OutputIterator,
typename _UnaryOperation>
_OutputIterator
transform(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _UnaryOperation __unary_op)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _BinaryOperation>
_OutputIterator
transform(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _OutputIterator __result,
_BinaryOperation __binary_op)
;
template<typename _ForwardIterator, typename _Tp>
void
replace(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __old_value, const _Tp& __new_value)
;
template<typename _ForwardIterator, typename _Predicate, typename _Tp>
void
replace_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, const _Tp& __new_value)
;
template<typename _ForwardIterator, typename _Generator>
void
generate(_ForwardIterator __first, _ForwardIterator __last,
_Generator __gen)
;
template<typename _OutputIterator, typename _Size, typename _Generator>
_OutputIterator
generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
;
template<typename _InputIterator, typename _OutputIterator>
_OutputIterator
unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result)
;
template<typename _InputIterator, typename _OutputIterator,
typename _BinaryPredicate>
_OutputIterator
unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result,
_BinaryPredicate __binary_pred)
;
template<typename _RandomAccessIterator>
void
random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
void
random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
_RandomNumberGenerator& __rand)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _RandomAccessIterator>
void
partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator>
void
sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
__merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator,
typename _Compare>
_OutputIterator
__set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator,
typename _Compare>
_OutputIterator
__set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator,
typename _Compare>
_OutputIterator
__set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
;
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)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
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)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
__min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator>
_ForwardIterator
min_element(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
__max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator>
_ForwardIterator
max_element(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
}
namespace boost {
namespace detail {
struct unspecified_bool
{
struct OPERATORS_NOT_ALLOWED;
static void true_value(OPERATORS_NOT_ALLOWED*) ;
};
typedef void (*unspecified_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*);
}
}
namespace boost {
class bad_optional_access : public std::logic_error
{
public:
bad_optional_access()
;
};
}
namespace
boost
{
namespace
exception_detail
{
template <class T>
class
refcount_ptr
{
public:
refcount_ptr()
;
~refcount_ptr()
;
refcount_ptr( refcount_ptr const & x )
;
refcount_ptr &
operator=( refcount_ptr const & x )
;
void
adopt( T * px )
;
T *
get() const
;
private:
T * px_;
void
add_ref()
;
void
release()
;
};
}
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 )
;
};
template <>
class
error_info<throw_file_,char const *>
{
public:
typedef char const * value_type;
value_type v_;
explicit
error_info( value_type v )
;
};
template <>
class
error_info<throw_line_,int>
{
public:
typedef int value_type;
value_type v_;
explicit
error_info( value_type v )
;
};
class exception;
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 & );
}
class
exception
{
public:
template <class Tag> void set( typename Tag::type const & );
template <class Tag> typename Tag::type const * get() const;
protected:
exception()
;
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_;
};
namespace
exception_detail
{
template <class E>
E const &
set_info( E const & x, throw_function const & y )
;
template <class E>
E const &
set_info( E const & x, throw_file const & y )
;
template <class E>
E const &
set_info( E const & x, throw_line const & y )
;
}
namespace
exception_detail
{
template <class T>
struct
error_info_injector:
public T,
public exception
{
explicit
error_info_injector( T const & x )
;
~error_info_injector() throw()
;
};
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>
typename
exception_detail::enable_error_info_return_type<T>::type
enable_error_info( T const & x )
;
namespace
exception_detail
{
class
clone_base
{
public:
virtual clone_base const * clone() const = 0;
virtual void rethrow() const = 0;
virtual
~clone_base() throw()
;
};
void
copy_boost_exception( exception * a, exception const * b )
;
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 )
;
public:
explicit
clone_impl( T const & x )
;
~clone_impl() throw()
;
private:
clone_base const *
clone() const
;
void
rethrow() const
;
};
}
template <class T>
exception_detail::clone_impl<T>
enable_current_exception( T const & x )
;
}
namespace boost
{
namespace detail
{
void current_function_helper()
;
}
}
namespace boost
{
void throw_exception_assert_compatibility( std::exception const & ) ;
template<class E> __attribute__ ((__noreturn__)) void throw_exception( E const & e )
;
namespace
exception_detail
{
template <class E>
__attribute__ ((__noreturn__))
void
throw_exception_( E const & x, char const * current_function, char const * file, int line )
;
}
}
namespace boost {
template <class T>
struct type {};
}
namespace mpl_ {
template< std::size_t N > struct size_t;
}
namespace boost { namespace mpl { using ::mpl_::size_t; } }
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;
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 ;
};
template< std::size_t N >
std::size_t const mpl_::size_t< N >::value;
}
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
{
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*>
{
};
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: };
}
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: };
}
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: };
}
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>
{
};
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: };
}
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: };
}
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: };
}
namespace boost { namespace mpl { namespace aux {
template< typename T > struct value_type_wknd
{
typedef typename T::value_type type;
};
}}}
namespace mpl_ {
struct void_;
}
namespace boost { namespace mpl { using ::mpl_::void_; } }
namespace mpl_ {
struct na
{
typedef na type;
enum { value = 0 };
};
}
namespace boost { namespace mpl { using ::mpl_::na; } }
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;
};
}}
namespace boost { namespace mpl {
template<
typename T = na
, typename Tag = void_
, typename Arity = int_< aux::template_arity<T>::value >
>
struct lambda;
}}
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;
};
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> { }; }
}}
namespace boost {
namespace detail {
class alignment_dummy;
typedef void (*function_ptr)();
typedef int (alignment_dummy::*member_ptr);
typedef int (alignment_dummy::*member_function_ptr)();
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;
};
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;
};
template<std::size_t TAlign, std::size_t Align>
struct is_aligned
{
static const
bool value = (TAlign >= Align) & (TAlign % Align == 0)
;
};
}
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;
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
found >= Align
) == 0 ? false : true) >)> boost_static_assert_typedef_164 __attribute__((unused))
;
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
found % Align == 0
) == 0 ? false : true) >)> boost_static_assert_typedef_165 __attribute__((unused))
;
public:
typedef align_t type;
};
}
template <std::size_t Align>
class type_with_alignment
: public ::boost::detail::type_with_alignment_imp<Align>
{
};
namespace tt_align_ns {
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 tt_align_ns::a2 type; };
template<> class type_with_alignment<4> { public: typedef tt_align_ns::a4 type; };
template<> class type_with_alignment<8> { public: typedef tt_align_ns::a8 type; };
template<> class type_with_alignment<16> { public: typedef tt_align_ns::a16 type; };
template<> class type_with_alignment<32> { public: typedef tt_align_ns::a32 type; };
template<> class type_with_alignment<64> { public: typedef tt_align_ns::a64 type; };
template<> class type_with_alignment<128> { public: typedef tt_align_ns::a128 type; };
namespace detail {
template<> struct is_pod_impl< ::boost::tt_align_ns::a2 > { public:
static const
bool value = (true); };
template<> struct is_pod_impl< ::boost::tt_align_ns::a4 > { public:
static const
bool value = (true); };
template<> struct is_pod_impl< ::boost::tt_align_ns::a8 > { public:
static const
bool value = (true); };
template<> struct is_pod_impl< ::boost::tt_align_ns::a16 > { public:
static const
bool value = (true); };
template<> struct is_pod_impl< ::boost::tt_align_ns::a32 > { public:
static const
bool value = (true); };
template<> struct is_pod_impl< ::boost::tt_align_ns::a64 > { public:
static const
bool value = (true); };
template<> struct is_pod_impl< ::boost::tt_align_ns::a128 > { public:
static const
bool value = (true); };
}
}
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 { 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]; };
}
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: };
}
namespace boost {
namespace type_traits {
struct false_result
{
template <typename T> struct result_
{
static const
bool value = false;
};
};
}}
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; };
}
}
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>
{
};
}
template< typename T > struct is_function : public ::boost::integral_constant<bool,::boost::detail::is_function_impl<T>::value> { public: };
}
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; };
}
namespace boost {
namespace detail {
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; };
}
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> { }; }
}}
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> { }; }
}}
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;
};
}
namespace boost {
namespace detail {
template <typename B, typename D>
struct is_base_and_derived_impl
{
typedef typename remove_cv<B>::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: };
}
namespace boost {
namespace detail {
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: };
}
namespace boost {
namespace detail{
template <class B, class D>
struct is_base_of_imp
{
typedef typename remove_cv<B>::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: };
}
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< 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: };
}
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: };
}
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);
};
}
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: };
}
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: };
}
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> {};
}
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_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; };
}
namespace boost {
template <typename T>
typename add_rvalue_reference<T>::type declval() ;
}
namespace boost {
namespace detail{
template <class T>
struct is_nothrow_move_assignable_imp{
static const
bool value = ( ::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::has_trivial_move_assign<T>::value, ::boost::has_nothrow_assign<T>::value >::value, ::boost::type_traits::ice_not< ::boost::is_array<T>::value >::value >::value)
;
};
}
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: };
}
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: };
}
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: };
}
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: };
}
namespace boost {
namespace detail{
template <class T>
struct is_nothrow_move_constructible_imp{
static const
bool value =( ::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::has_trivial_move_constructor<T>::value, ::boost::has_nothrow_copy<T>::value >::value, ::boost::type_traits::ice_not< ::boost::is_array<T>::value >::value >::value)
;
};
}
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: };
}
namespace boost { namespace mpl { namespace aux {
template< typename T > struct nested_type_wknd
: T::type
{
};
}}}
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> { }; }
}}
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> { }; }
}}
namespace boost {
namespace detail {
template <typename RefT>
class reference_content
{
private:
RefT content_;
public:
~reference_content()
;
reference_content(RefT r)
;
reference_content(const reference_content& operand)
;
private:
reference_content& operator=(const reference_content&);
public:
RefT get() const
;
};
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;
};
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_
{
};
}
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_ : if_c<0 != T1::value, T2, T3>
{};
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 : enable_if_c<Cond::value, T> {};
template <class Cond, class T = void>
struct disable_if : 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;
};
typedef integral_constant<bool, true > true_type;
typedef integral_constant<bool, false > false_type;
template <class T>
struct identity
{
typedef T type;
};
template<class T, class U>
struct is_same
{
static const bool value = false;
};
template<class T>
struct is_same<T, T>
{
static const bool value = true;
};
}
}
namespace boost {
template <class T> class rv;
namespace move_detail {
struct nat{};
template <class T> struct natify{};
template<class T>
struct remove_reference
{
typedef T type;
};
template<class T>
struct remove_reference<T&>
{
typedef T type;
};
template<class T>
struct remove_reference< rv<T> >
{
typedef T type;
};
template<class T>
struct remove_reference< rv<T> &>
{
typedef T type;
};
template<class T>
struct remove_reference< const rv<T> &>
{
typedef T type;
};
template<class T>
struct add_const
{
typedef const T type;
};
template<class T>
struct add_const<T&>
{
typedef const T& type;
};
template<class T>
struct add_lvalue_reference
{ typedef T& type; };
template<class T> struct add_lvalue_reference<T&> { typedef T& type; };
template<> struct add_lvalue_reference<void> { typedef void type; };
template<> struct add_lvalue_reference<const void> { typedef const void type; };
template<> struct add_lvalue_reference<volatile void> { typedef volatile void type; };
template<> struct add_lvalue_reference<const volatile void>{ typedef const volatile void type; };
template<class T>
struct add_const_lvalue_reference
{
typedef typename remove_reference<T>::type t_unreferenced;
typedef typename add_const<t_unreferenced>::type t_unreferenced_const;
typedef typename add_lvalue_reference
<t_unreferenced_const>::type type;
};
template<class T>
struct is_lvalue_reference
{
static const bool value = false;
};
template<class T>
struct is_lvalue_reference<T&>
{
static const bool value = true;
};
template<class T>
struct is_class_or_union
{
struct twochar { char dummy[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);
};
template<class T>
struct addr_impl_ref
{
T & v_;
addr_impl_ref( T & v ) ;
operator T& () const ;
private:
addr_impl_ref & operator=(const addr_impl_ref &);
};
template<class T>
struct addressof_impl
{
static T * f( T & v, long )
;
static T * f( T * v, int )
;
};
template<class T>
T * addressof( T & v )
;
template <class T>
struct has_pointer_type
{
struct two { char c[2]; };
template <class U> static two test(...);
template <class U> static char test(typename U::pointer* = 0);
static const bool value = sizeof(test<T>(0)) == 1;
};
template <class T, class U>
class is_convertible
{
typedef typename add_lvalue_reference<T>::type t_reference;
typedef char true_t;
class false_t { char dummy[2]; };
static false_t dispatch(...);
static true_t dispatch(U);
static t_reference trigger();
public:
static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t);
};
template<class T>
struct has_move_emulation_enabled_impl
: is_convertible< T, ::boost::rv<T>& >
{};
template<class T>
struct has_move_emulation_enabled_impl<T&>
{ static const bool value = false; };
template<class T>
struct has_move_emulation_enabled_impl< ::boost::rv<T> >
{ static const bool value = false; };
template <class T>
struct is_rv_impl
{ static const bool value = false; };
template <class T>
struct is_rv_impl< rv<T> >
{ static const bool value = true; };
template <class T>
struct is_rv_impl< const rv<T> >
{ static const bool value = true; };
template< class T >
struct is_rvalue_reference
{ static const bool value = false; };
template< class T >
struct is_rvalue_reference< boost::rv<T>& >
{ static const bool value = true; };
template< class T >
struct is_rvalue_reference< const boost::rv<T>& >
{ static const bool value = true; };
namespace detail_add_rvalue_reference
{
template< class T
, bool emulation = has_move_emulation_enabled_impl<T>::value
, bool rv = is_rv_impl<T>::value >
struct add_rvalue_reference_impl { typedef T type; };
template< class T, bool emulation>
struct add_rvalue_reference_impl< T, emulation, true > { typedef T & type; };
template< class T, bool rv >
struct add_rvalue_reference_impl< T, true, rv > { typedef ::boost::rv<T>& type; };
}
template< class T >
struct add_rvalue_reference
: detail_add_rvalue_reference::add_rvalue_reference_impl<T>
{ };
template< class T >
struct add_rvalue_reference<T &>
{ typedef T & type; };
template< class T > struct remove_rvalue_reference { typedef T type; };
template< class T > struct remove_rvalue_reference< rv<T> > { typedef T type; };
template< class T > struct remove_rvalue_reference< const rv<T> > { typedef T type; };
template< class T > struct remove_rvalue_reference< volatile rv<T> > { typedef T type; };
template< class T > struct remove_rvalue_reference< const volatile rv<T> > { typedef T type; };
template< class T > struct remove_rvalue_reference< rv<T>& > { typedef T type; };
template< class T > struct remove_rvalue_reference< const rv<T>& > { typedef T type; };
template< class T > struct remove_rvalue_reference< volatile rv<T>& > { typedef T type; };
template< class T > struct remove_rvalue_reference< const volatile rv<T>& >{ typedef T type; };
}
}
namespace boost {
namespace move_detail {
template<class T>
struct is_reference
{ static const bool value = false; };
template<class T>
struct is_reference<T&>
{ static const bool value = true; };
template<class T>
struct is_pointer
{ static const bool value = false; };
template<class T>
struct is_pointer<T*>
{ static const bool value = true; };
template <typename T>
struct add_reference
{ typedef T& type; };
template<class T>
struct add_reference<T&>
{ typedef T& type; };
template<>
struct add_reference<void>
{ typedef nat &type; };
template<>
struct add_reference<const void>
{ typedef const nat &type; };
template <class T>
struct add_const_reference
{ typedef const T &type; };
template <class T>
struct add_const_reference<T&>
{ typedef T& type; };
template<class T>
struct remove_const
{ typedef T type; };
template<class T>
struct remove_const< const T>
{ typedef T type; };
template<typename T> struct remove_cv { typedef T type; };
template<typename T> struct remove_cv<const T> { typedef T type; };
template<typename T> struct remove_cv<const volatile T> { typedef T type; };
template<typename T> struct remove_cv<volatile T> { typedef T type; };
template <class T>
struct make_unsigned_impl { typedef T type; };
template <> struct make_unsigned_impl<signed char> { typedef unsigned char type; };
template <> struct make_unsigned_impl<signed short> { typedef unsigned short type; };
template <> struct make_unsigned_impl<signed int> { typedef unsigned int type; };
template <> struct make_unsigned_impl<signed long> { typedef unsigned long type; };
template <> struct make_unsigned_impl< ::boost::long_long_type > { typedef ::boost::ulong_long_type type; };
template <class T>
struct make_unsigned
: make_unsigned_impl<typename remove_cv<T>::type>
{};
template<class T> struct is_floating_point_cv { static const bool value = false; };
template<> struct is_floating_point_cv<float> { static const bool value = true; };
template<> struct is_floating_point_cv<double> { static const bool value = true; };
template<> struct is_floating_point_cv<long double> { static const bool value = true; };
template<class T>
struct is_floating_point
: is_floating_point_cv<typename remove_cv<T>::type>
{};
template<class T> struct is_integral_cv { static const bool value = false; };
template<> struct is_integral_cv< bool>{ static const bool value = true; };
template<> struct is_integral_cv< char>{ static const bool value = true; };
template<> struct is_integral_cv< unsigned char>{ static const bool value = true; };
template<> struct is_integral_cv< signed char>{ static const bool value = true; };
template<> struct is_integral_cv< wchar_t>{ static const bool value = true; };
template<> struct is_integral_cv< short>{ static const bool value = true; };
template<> struct is_integral_cv< unsigned short>{ static const bool value = true; };
template<> struct is_integral_cv< int>{ static const bool value = true; };
template<> struct is_integral_cv< unsigned int>{ static const bool value = true; };
template<> struct is_integral_cv< long>{ static const bool value = true; };
template<> struct is_integral_cv< unsigned long>{ static const bool value = true; };
template<> struct is_integral_cv< ::boost:: long_long_type>{ static const bool value = true; };
template<> struct is_integral_cv< ::boost::ulong_long_type>{ static const bool value = true; };
template<class T>
struct is_integral
: public is_integral_cv<typename remove_cv<T>::type>
{};
template <class T>
struct remove_all_extents
{ typedef T type;};
template <class T>
struct remove_all_extents<T[]>
{ typedef typename remove_all_extents<T>::type type; };
template <class T, size_t N>
struct remove_all_extents<T[N]>
{ typedef typename remove_all_extents<T>::type type;};
template<class T>
struct is_scalar
{ static const bool value = is_integral<T>::value || is_floating_point<T>::value; };
template<class T>
struct is_void_cv
{ static const bool value = false; };
template<>
struct is_void_cv<void>
{ static const bool value = true; };
template<class T>
struct is_void
: is_void_cv<typename remove_cv<T>::type>
{};
template<class T>
struct is_array
{ static const bool value = false; };
template<class T>
struct is_array<T[]>
{ static const bool value = true; };
template<class T, std::size_t N>
struct is_array<T[N]>
{ static const bool value = true; };
template <class T> struct is_member_pointer_cv { static const bool value = false; };
template <class T, class U>struct is_member_pointer_cv<T U::*> { static const bool value = true; };
template <class T>
struct is_member_pointer
: is_member_pointer_cv<typename remove_cv<T>::type>
{};
template <class T>
struct is_nullptr_t_cv
{ static const bool value = false; };
template <class T>
struct is_nullptr_t
: is_nullptr_t_cv<typename remove_cv<T>::type>
{};
template <class T>
struct is_reference_convertible_to_pointer
{
struct twochar { char dummy[2]; };
template <class U> static char test(U*);
template <class U> static twochar test(...);
static T& source();
static const bool value = sizeof(char) == sizeof(test<T>(source()));
};
template < class T
, bool Filter = is_class_or_union<T>::value ||
is_void<T>::value ||
is_reference<T>::value ||
is_nullptr_t<T>::value >
struct is_function_impl
{ static const bool value = is_reference_convertible_to_pointer<T>::value; };
template <class T>
struct is_function_impl<T, true>
{ static const bool value = false; };
template <class T>
struct is_function
: is_function_impl<T>
{};
template<class T>
struct is_union_noextents_cv
{ static const bool value = __is_union(T); };
template<class T>
struct is_union
: is_union_noextents_cv<typename remove_cv<typename remove_all_extents<T>::type>::type>
{};
template <class T>
struct is_class
{
static const bool value = is_class_or_union<T>::value && ! is_union<T>::value;
};
template <class T>
struct is_arithmetic
{
static const bool value = is_floating_point<T>::value ||
is_integral<T>::value;
};
template <class T>
struct is_member_function_pointer_cv
{
static const bool value = false;
};
template <class T, class C>
struct is_member_function_pointer_cv<T C::*>
: is_function<T>
{};
template <class T>
struct is_member_function_pointer
: is_member_function_pointer_cv<typename remove_cv<T>::type>
{};
template <class T>
struct is_enum
{ static const bool value = __is_enum(T); };
template<class T>
struct is_pod_noextents_cv
{ static const bool value = __is_pod(T); };
template<class T>
struct is_pod
: is_pod_noextents_cv<typename remove_cv<typename remove_all_extents<T>::type>::type>
{};
template <class T>
struct is_empty
{ static const bool value = __is_empty(T); };
template<class T>
struct is_copy_constructible
{
typedef char yes_type;
struct no_type { char dummy[2]; };
template<class U> static typename add_reference<U>::type source();
template <class U>
static no_type test(U&, typename U::boost_move_no_copy_constructor_or_assign* = 0);
static yes_type test(...);
static const bool value = sizeof(test(source<T>())) == sizeof(yes_type);
};
template<class T>
struct is_trivially_destructible
{ static const bool value = (__has_trivial_destructor(T) ); };
template<class T>
struct is_trivially_default_constructible
{ static const bool value = ((__has_trivial_constructor(T) )); };
template<class T>
struct is_trivially_copy_constructible
{ static const bool value = ((__has_trivial_copy(T) )); };
template<class T>
struct is_trivially_move_constructible
{ static const bool value = ::boost::move_detail::is_pod<T>::value; };
template<class T>
struct is_trivially_copy_assignable
{ static const bool value = ((__has_trivial_assign(T) ) ); };
template<class T>
struct is_trivially_move_assignable
{ static const bool value = ::boost::move_detail::is_pod<T>::value; };
template<class T>
struct is_nothrow_default_constructible
: is_pod<T>
{ static const bool value = (__has_nothrow_constructor(T) ); };
template<class T>
struct is_nothrow_copy_constructible
{ static const bool value = ((__has_nothrow_copy(T) )); };
template<class T>
struct is_nothrow_move_constructible
{ static const bool value = ::boost::move_detail::is_pod<T>::value; };
template<class T>
struct is_nothrow_copy_assignable
{ static const bool value = ((__has_nothrow_assign(T) )); };
template<class T>
struct is_nothrow_move_assignable
{ static const bool value = ::boost::move_detail::is_pod<T>::value; };
template<class T>
struct is_nothrow_swappable
{
static const bool value = is_empty<T>::value || is_pod<T>::value;
};
template <typename T>
struct alignment_of_hack
{
T t1;
char c;
T t2;
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
{ static const std::size_t value = __alignof__(T); };
template< typename T >
struct alignment_of
: alignment_of_impl<T>
{};
class alignment_dummy;
typedef void (*function_ptr)();
typedef int (alignment_dummy::*member_ptr);
typedef int (alignment_dummy::*member_function_ptr)();
struct alignment_struct
{ long double dummy[4]; };
union max_align
{
char char_;
short short_;
int int_;
long long_;
::boost::long_long_type long_long_;
float float_;
double double_;
void * void_ptr_;
long double long_double_[4];
alignment_dummy *unknown_class_ptr_;
function_ptr function_ptr_;
member_function_ptr member_function_ptr_;
alignment_struct alignment_struct_;
};
typedef union max_align max_align_t;
template<std::size_t Len, std::size_t Align>
struct aligned_storage_impl;
template<std::size_t Len>struct
__attribute__ ((__aligned__(
0x1
)))
aligned_storage_impl<Len, 0x1>{ char dummy[Len]; typedef aligned_storage_impl<Len, 0x1> type;};
template<std::size_t Len>struct
__attribute__ ((__aligned__(
0x2
)))
aligned_storage_impl<Len, 0x2>{ char dummy[Len]; typedef aligned_storage_impl<Len, 0x2> type;};
template<std::size_t Len>struct
__attribute__ ((__aligned__(
0x4
)))
aligned_storage_impl<Len, 0x4>{ char dummy[Len]; typedef aligned_storage_impl<Len, 0x4> type;};
template<std::size_t Len>struct
__attribute__ ((__aligned__(
0x8
)))
aligned_storage_impl<Len, 0x8>{ char dummy[Len]; typedef aligned_storage_impl<Len, 0x8> type;};
template<std::size_t Len>struct
__attribute__ ((__aligned__(
0x10
)))
aligned_storage_impl<Len, 0x10>{ char dummy[Len]; typedef aligned_storage_impl<Len, 0x10> type;};
template<std::size_t Len>struct
__attribute__ ((__aligned__(
0x20
)))
aligned_storage_impl<Len, 0x20>{ char dummy[Len]; typedef aligned_storage_impl<Len, 0x20> type;};
template<std::size_t Len>struct
__attribute__ ((__aligned__(
0x40
)))
aligned_storage_impl<Len, 0x40>{ char dummy[Len]; typedef aligned_storage_impl<Len, 0x40> type;};
template<std::size_t Len>struct
__attribute__ ((__aligned__(
0x80
)))
aligned_storage_impl<Len, 0x80>{ char dummy[Len]; typedef aligned_storage_impl<Len, 0x80> type;};
template<std::size_t Len>struct
__attribute__ ((__aligned__(
0x100
)))
aligned_storage_impl<Len, 0x100>{ char dummy[Len]; typedef aligned_storage_impl<Len, 0x100> type;};
template<std::size_t Len>struct
__attribute__ ((__aligned__(
0x200
)))
aligned_storage_impl<Len, 0x200>{ char dummy[Len]; typedef aligned_storage_impl<Len, 0x200> type;};
template<std::size_t Len>struct
__attribute__ ((__aligned__(
0x400
)))
aligned_storage_impl<Len, 0x400>{ char dummy[Len]; typedef aligned_storage_impl<Len, 0x400> type;};
template<std::size_t Len>struct
__attribute__ ((__aligned__(
0x800
)))
aligned_storage_impl<Len, 0x800>{ char dummy[Len]; typedef aligned_storage_impl<Len, 0x800> type;};
template<std::size_t Len>struct
__attribute__ ((__aligned__(
0x1000
)))
aligned_storage_impl<Len, 0x1000>{ char dummy[Len]; typedef aligned_storage_impl<Len, 0x1000> type;};
template<std::size_t Len, std::size_t Align = alignment_of<max_align_t>::value>
struct aligned_storage
{
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
Align > 0
) == 0 ? false : true) >)> boost_static_assert_typedef_984 __attribute__((unused))
;
typedef typename aligned_storage_impl<Len ? Len : 1, Align>::type type;
static const std::size_t value = alignment_of<type>::value;
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
value >= Align
) == 0 ? false : true) >)> boost_static_assert_typedef_989 __attribute__((unused))
;
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
(value % Align) == 0
) == 0 ? false : true) >)> boost_static_assert_typedef_990 __attribute__((unused))
;
private:
aligned_storage();
};
}
}
namespace boost {
template <class T>
class rv
: public ::boost::move_detail::if_c
< ::boost::move_detail::is_class<T>::value
, T
, ::boost::move_detail::nat
>::type
{
rv();
~rv() throw();
rv(rv const&);
void operator=(rv const&);
} __attribute__((__may_alias__));
namespace move_detail {
template <class T>
struct is_rv
: integral_constant<bool, ::boost::move_detail::is_rv_impl<T>::value >
{};
}
template<class T>
struct has_move_emulation_enabled
: ::boost::move_detail::has_move_emulation_enabled_impl<T>
{};
}
namespace boost {
namespace move_detail {
template <class Ret, class T>
typename ::boost::move_detail::enable_if_c
< ::boost::move_detail::is_lvalue_reference<Ret>::value ||
!::boost::has_move_emulation_enabled<T>::value
, T&>::type
move_return(T& x)
;
template <class Ret, class T>
typename ::boost::move_detail::enable_if_c
< !::boost::move_detail::is_lvalue_reference<Ret>::value &&
::boost::has_move_emulation_enabled<T>::value
, ::boost::rv<T>&>::type
move_return(T& x)
;
template <class Ret, class T>
typename ::boost::move_detail::enable_if_c
< !::boost::move_detail::is_lvalue_reference<Ret>::value &&
::boost::has_move_emulation_enabled<T>::value
, ::boost::rv<T>&>::type
move_return(::boost::rv<T>& x)
;
}
}
namespace boost{
namespace move_detail{
template< class T>
struct forward_type
{ typedef const T &type; };
template< class T>
struct forward_type< boost::rv<T> >
{ typedef T type; };
}}
namespace boost {
template<class T>
struct enable_move_utility_emulation
{
static const bool value = true;
};
template <class T>
typename ::boost::move_detail::enable_if_c
< enable_move_utility_emulation<T>::value && !has_move_emulation_enabled<T>::value, T&>::type
move(T& x)
;
template <class T>
typename ::boost::move_detail::enable_if_c
< enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value, rv<T>&>::type
move(T& x)
;
template <class T>
typename ::boost::move_detail::enable_if_c
< enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value, rv<T>&>::type
move(rv<T>& x)
;
template <class T>
typename ::boost::move_detail::enable_if_c
< enable_move_utility_emulation<T>::value && ::boost::move_detail::is_rv<T>::value, T &>::type
forward(const typename ::boost::move_detail::identity<T>::type &x)
;
template <class T>
typename ::boost::move_detail::enable_if_c
< enable_move_utility_emulation<T>::value && !::boost::move_detail::is_rv<T>::value, const T &>::type
forward(const typename ::boost::move_detail::identity<T>::type &x)
;
template <class T>
typename ::boost::move_detail::enable_if_c
< enable_move_utility_emulation<T>::value &&
::boost::move_detail::is_rv<T>::value
, T &>::type
move_if_not_lvalue_reference(const typename ::boost::move_detail::identity<T>::type &x)
;
template <class T>
typename ::boost::move_detail::enable_if_c
< enable_move_utility_emulation<T>::value &&
!::boost::move_detail::is_rv<T>::value &&
(::boost::move_detail::is_lvalue_reference<T>::value ||
!has_move_emulation_enabled<T>::value)
, typename ::boost::move_detail::add_lvalue_reference<T>::type
>::type
move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type &x)
;
template <class T>
typename ::boost::move_detail::enable_if_c
< enable_move_utility_emulation<T>::value &&
!::boost::move_detail::is_rv<T>::value &&
(!::boost::move_detail::is_lvalue_reference<T>::value &&
has_move_emulation_enabled<T>::value)
, rv<T>&
>::type
move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type &x)
;
}
namespace boost{
namespace move_detail{
template <typename T>
typename boost::move_detail::add_rvalue_reference<T>::type declval();
}
}
namespace boost {
template <class T>
struct has_trivial_destructor_after_move
: ::boost::move_detail::is_trivially_destructible<T>
{};
template <class T>
struct has_nothrow_move
{
static const bool value = boost::move_detail::is_nothrow_move_constructible<T>::value &&
boost::move_detail::is_nothrow_move_assignable<T>::value;
};
namespace move_detail {
template <class T>
struct is_nothrow_move_constructible_or_uncopyable
{
static const bool value = is_nothrow_move_constructible<T>::value ||
has_nothrow_move<T>::value ||
!is_copy_constructible<T>::value;
};
}
}
namespace boost {
template <class T>
typename ::boost::move_detail::enable_if_c
< enable_move_utility_emulation<T>::value && !has_move_emulation_enabled<T>::value
, typename ::boost::move_detail::add_const<T>::type &
>::type
move_if_noexcept(T& x)
;
template <class T>
typename ::boost::move_detail::enable_if_c
< enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value
&& ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value, rv<T>&>::type
move_if_noexcept(T& x)
;
template <class T>
typename ::boost::move_detail::enable_if_c
< enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value
&& ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value
, rv<T>&
>::type
move_if_noexcept(rv<T>& x)
;
template <class T>
typename ::boost::move_detail::enable_if_c
< enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value
&& !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value
, typename ::boost::move_detail::add_const<T>::type &
>::type
move_if_noexcept(T& x)
;
template <class T>
typename ::boost::move_detail::enable_if_c
< enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value
&& !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value
, typename ::boost::move_detail::add_const<T>::type &
>::type
move_if_noexcept(rv<T>& x)
;
}
namespace boost {
class none_t {};
}
namespace boost {
namespace detail { namespace optional_detail {
template <typename T>
struct none_instance
{
static const T instance;
};
template <typename T>
const T none_instance<T>::instance = T();
} }
namespace {
const none_t& none = detail::optional_detail::none_instance<none_t>::instance;
}
}
namespace boost
{
namespace detail
{
template<class T> struct addr_impl_ref
{
T & v_;
__attribute__ ((__always_inline__))
addr_impl_ref( T & v ) ;
__attribute__ ((__always_inline__))
operator T& () const ;
private:
addr_impl_ref & operator=(const addr_impl_ref &);
};
template<class T> struct addressof_impl
{
static
__attribute__ ((__always_inline__))
T * f( T & v, long )
;
static
__attribute__ ((__always_inline__))
T * f( T * v, int )
;
};
}
template<class T>
__attribute__ ((__always_inline__))
T * addressof( T & v )
;
}
namespace boost {
template<class OptionalPointee>
bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y )
;
template<class OptionalPointee>
struct equal_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
{
bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
;
} ;
template<class OptionalPointee>
bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y )
;
template<class OptionalPointee>
struct less_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
{
bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
;
} ;
}
namespace boost {
class in_place_factory_base {} ;
class in_place_factory0
:
public in_place_factory_base
{
public:
explicit in_place_factory0
( )
;
template<class T>
void* apply(void* address) const
;
template<class T>
void* apply(void* address, std::size_t n) const
;
};
in_place_factory0 in_place()
;
template< class A0 >
class in_place_factory1
:
public in_place_factory_base
{
public:
explicit in_place_factory1
( A0 const& a0 )
;
template<class T>
void* apply(void* address) const
;
template<class T>
void* apply(void* address, std::size_t n) const
;
A0 const& m_a0;
};
template< class A0 >
in_place_factory1< A0 >
in_place( A0 const& a0 )
;
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 )
;
template<class T>
void* apply(void* address) const
;
template<class T>
void* apply(void* address, std::size_t n) const
;
A0 const& m_a0; A1 const& m_a1;
};
template< class A0 , class A1 >
in_place_factory2< A0 , A1 >
in_place( A0 const& a0 , A1 const& a1 )
;
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 )
;
template<class T>
void* apply(void* address) const
;
template<class T>
void* apply(void* address, std::size_t n) const
;
A0 const& m_a0; A1 const& m_a1; A2 const& m_a2;
};
template< class A0 , class A1 , class A2 >
in_place_factory3< A0 , A1 , A2 >
in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 )
;
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 )
;
template<class T>
void* apply(void* address) const
;
template<class T>
void* apply(void* address, std::size_t n) const
;
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 >
in_place_factory4< A0 , A1 , A2 , A3 >
in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 )
;
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 )
;
template<class T>
void* apply(void* address) const
;
template<class T>
void* apply(void* address, std::size_t n) const
;
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 >
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 )
;
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 )
;
template<class T>
void* apply(void* address) const
;
template<class T>
void* apply(void* address, std::size_t n) const
;
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 >
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 )
;
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 )
;
template<class T>
void* apply(void* address) const
;
template<class T>
void* apply(void* address, std::size_t n) const
;
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 >
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 )
;
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 )
;
template<class T>
void* apply(void* address) const
;
template<class T>
void* apply(void* address, std::size_t n) const
;
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 >
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 )
;
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 )
;
template<class T>
void* apply(void* address) const
;
template<class T>
void* apply(void* address, std::size_t n) const
;
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 >
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 )
;
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 )
;
template<class T>
void* apply(void* address) const
;
template<class T>
void* apply(void* address, std::size_t n) const
;
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 >
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 )
;
}
namespace boost_swap_impl
{
template<class T>
void swap_impl(T& left, T& right)
;
template<class T, std::size_t N>
void swap_impl(T (& left)[N], T (& right)[N])
;
}
namespace boost
{
template<class T1, class T2>
void swap(T1& left, T2& right)
;
}
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 ;
}
namespace boost_optional_detail
{
template <class T, class Factory>
void construct(Factory const& factory, void* 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 ;
void * address() ;
} ;
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 ;
} ;
template <class To, class From>
void prevent_binding_rvalue_ref_to_optional_lvalue_ref()
;
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
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() ;
optional_base ( none_t ) ;
optional_base ( argument_type val )
;
optional_base ( bool cond, argument_type val )
;
optional_base ( optional_base const& rhs )
;
template<class Expr>
explicit optional_base ( Expr const& expr, Expr const* tag )
;
~optional_base() ;
void assign ( optional_base const& rhs )
;
template<class U>
void assign ( optional<U> const& rhs )
;
void assign ( argument_type val )
;
void assign ( none_t ) ;
template<class Expr>
void assign_expr ( Expr const& expr, Expr const* tag )
;
public :
void reset() ;
void reset ( argument_type val ) ;
pointer_const_type get_ptr() const ;
pointer_type get_ptr() ;
bool is_initialized() const ;
protected :
void construct ( argument_type val )
;
template<class Arg>
void emplace_assign ( const Arg& arg )
;
template<class Arg>
void emplace_assign ( Arg& arg )
;
template<class Expr>
void construct ( Expr const& factory, in_place_factory_base const* )
;
template<class Expr>
void construct ( Expr const& factory, typed_in_place_factory_base const* )
;
template<class Expr>
void assign_expr_to_initialized ( Expr const& factory, in_place_factory_base const* tag )
;
template<class Expr>
void assign_expr_to_initialized ( Expr const& factory, typed_in_place_factory_base const* tag )
;
template<class Expr>
void construct ( Expr const& expr, void const* )
;
template<class Expr>
void assign_expr_to_initialized ( Expr const& expr, void const* )
;
void assign_value ( argument_type val, is_not_reference_tag ) ;
void assign_value ( argument_type val, is_reference_tag ) ;
void destroy()
;
reference_const_type get_impl() const ;
reference_type get_impl() ;
pointer_const_type get_ptr_impl() const ;
pointer_type get_ptr_impl() ;
private :
internal_type const* get_object() const
;
internal_type * get_object()
;
reference_const_type dereference( internal_type const* p, is_not_reference_tag ) const ;
reference_type dereference( internal_type* p, is_not_reference_tag ) ;
reference_const_type dereference( internal_type const* p, is_reference_tag ) const ;
reference_type dereference( internal_type* p, is_reference_tag ) ;
void destroy_impl ( is_not_reference_tag ) ;
void destroy_impl ( is_reference_tag ) ;
pointer_const_type cast_ptr( internal_type const* p, is_not_reference_tag ) const ;
pointer_type cast_ptr( internal_type * p, is_not_reference_tag ) ;
pointer_const_type cast_ptr( internal_type const* p, is_reference_tag ) const ;
pointer_type cast_ptr( internal_type * p, is_reference_tag ) ;
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 ;
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() ;
optional( none_t none_ ) ;
optional ( argument_type val ) ;
optional ( bool cond, argument_type val ) ;
template<class U>
explicit optional ( optional<U> const& rhs )
;
template<class Expr>
explicit optional ( Expr const& expr ) ;
optional ( optional const& rhs ) ;
~optional() ;
template<class Expr>
optional& operator= ( Expr const& expr )
;
template<class U>
optional& operator= ( optional<U> const& rhs )
;
optional& operator= ( optional const& rhs )
;
optional& operator= ( argument_type val )
;
optional& operator= ( none_t none_ )
;
template<class Arg>
void emplace ( const Arg& arg )
;
template<class Arg>
void emplace ( Arg& arg )
;
void swap( optional & arg )
;
reference_const_type get() const ;
reference_type get() ;
reference_const_type get_value_or ( reference_const_type v ) const ;
reference_type get_value_or ( reference_type v ) ;
pointer_const_type operator->() const ;
pointer_type operator->() ;
reference_const_type operator *() const ;
reference_type operator *() ;
reference_const_type value() const
;
reference_type value()
;
template <class U>
value_type value_or ( U const& v ) const
;
template <class U>
value_type value_or ( U& v ) const
;
template <typename F>
value_type value_or_eval ( F f ) const
;
bool operator!() const ;
__attribute__ ((__always_inline__))
operator boost::detail::unspecified_bool_type () const ;
} ;
template<class T>
optional<T> make_optional ( T const& v )
;
template<class T>
optional<T> make_optional ( bool cond, T const& v )
;
template<class T>
typename
optional<T>::reference_const_type
get ( optional<T> const& opt )
;
template<class T>
typename
optional<T>::reference_type
get ( optional<T>& opt )
;
template<class T>
typename
optional<T>::pointer_const_type
get ( optional<T> const* opt )
;
template<class T>
typename
optional<T>::pointer_type
get ( optional<T>* opt )
;
template<class T>
typename
optional<T>::reference_const_type
get_optional_value_or ( optional<T> const& opt,
typename
optional<T>::reference_const_type v )
;
template<class T>
typename
optional<T>::reference_type
get_optional_value_or ( optional<T>& opt,
typename
optional<T>::reference_type v )
;
template<class T>
typename
optional<T>::pointer_const_type
get_pointer ( optional<T> const& opt )
;
template<class T>
typename
optional<T>::pointer_type
get_pointer ( optional<T>& opt )
;
template<class CharType, class CharTrait>
std::basic_ostream<CharType, CharTrait>&
operator<<(std::basic_ostream<CharType, CharTrait>& out, optional_detail::optional_tag const& v)
;
template<class T>
bool operator == ( optional<T> const& x, optional<T> const& y )
;
template<class T>
bool operator < ( optional<T> const& x, optional<T> const& y )
;
template<class T>
bool operator != ( optional<T> const& x, optional<T> const& y )
;
template<class T>
bool operator > ( optional<T> const& x, optional<T> const& y )
;
template<class T>
bool operator <= ( optional<T> const& x, optional<T> const& y )
;
template<class T>
bool operator >= ( optional<T> const& x, optional<T> const& y )
;
template<class T>
bool operator == ( optional<T> const& x, T const& y )
;
template<class T>
bool operator < ( optional<T> const& x, T const& y )
;
template<class T>
bool operator != ( optional<T> const& x, T const& y )
;
template<class T>
bool operator > ( optional<T> const& x, T const& y )
;
template<class T>
bool operator <= ( optional<T> const& x, T const& y )
;
template<class T>
bool operator >= ( optional<T> const& x, T const& y )
;
template<class T>
bool operator == ( T const& x, optional<T> const& y )
;
template<class T>
bool operator < ( T const& x, optional<T> const& y )
;
template<class T>
bool operator != ( T const& x, optional<T> const& y )
;
template<class T>
bool operator > ( T const& x, optional<T> const& y )
;
template<class T>
bool operator <= ( T const& x, optional<T> const& y )
;
template<class T>
bool operator >= ( T const& x, optional<T> const& y )
;
template<class T>
bool operator == ( optional<T> const& x, none_t )
;
template<class T>
bool operator < ( optional<T> const& x, none_t )
;
template<class T>
bool operator != ( optional<T> const& x, none_t )
;
template<class T>
bool operator > ( optional<T> const& x, none_t y )
;
template<class T>
bool operator <= ( optional<T> const& x, none_t y )
;
template<class T>
bool operator >= ( optional<T> const& x, none_t y )
;
template<class T>
bool operator == ( none_t , optional<T> const& y )
;
template<class T>
bool operator < ( none_t , optional<T> const& y )
;
template<class T>
bool operator != ( none_t, optional<T> const& y )
;
template<class T>
bool operator > ( none_t x, optional<T> const& y )
;
template<class T>
bool operator <= ( none_t x, optional<T> const& y )
;
template<class T>
bool operator >= ( none_t x, optional<T> const& 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 )
;
};
template<>
struct swap_selector<false>
{
template<class T>
static void optional_swap ( optional<T>& x, optional<T>& y )
;
};
}
template<class T>
struct optional_swap_should_use_default_constructor : has_nothrow_default_constructor<T> {} ;
template<class T> void swap ( optional<T>& x, optional<T>& y )
;
}
namespace boost { namespace spirit {
namespace classic {
namespace impl
{
template <typename T>
struct no_base {};
template <typename T>
struct safe_bool_impl
{
typedef T* TP;
TP stub;
typedef TP safe_bool_impl::*type;
};
}
template <typename DerivedT, typename BaseT = impl::no_base<DerivedT> >
struct safe_bool : BaseT
{
private:
typedef impl::safe_bool_impl<DerivedT> impl_t;
typedef typename impl_t::type bool_type;
public:
operator bool_type() const
;
operator bool_type()
;
};
}
}}
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> { }; }
}}
namespace boost {
namespace detail{
template <class T>
struct is_abstract_imp
{
static const
bool value = __is_abstract(T);
};
}
template< typename T > struct is_abstract : public ::boost::integral_constant<bool,::boost::detail::is_abstract_imp<T>::value> { public: };
}
namespace boost {
namespace detail {
template <typename T>
struct add_reference_rvalue_layer
{
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; };
}
namespace boost{
template< typename T > struct add_lvalue_reference { public: typedef typename boost::add_reference<T>::type type; };
}
namespace boost {
namespace detail {
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(_m_from, 0) )
== sizeof(::boost::type_traits::yes_type);
};
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)
;
};
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
{};
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); };
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: };
}
namespace boost { namespace spirit {
namespace classic {
namespace impl
{
template <typename T>
struct match_attr_traits
{
typedef typename
boost::optional<T>::reference_const_type
const_reference;
template <typename T2>
static void
convert(boost::optional<T>& dest, T2 const& src, mpl::true_)
;
template <typename T2>
static void
convert(boost::optional<T>& dest, T2 const& , mpl::false_)
;
static void
convert(boost::optional<T>& dest, nil_t )
;
template <typename T2>
static void
convert(boost::optional<T>& dest, T2 const& src)
;
template <typename OtherMatchT>
static void
copy(boost::optional<T>& dest, OtherMatchT const& src)
;
template <typename OtherMatchT>
static void
assign(boost::optional<T>& dest, OtherMatchT const& src)
;
template <typename ValueT>
static void
set_value(boost::optional<T>& dest, ValueT const& val, mpl::false_)
;
template <typename ValueT>
static void
set_value(boost::optional<T>& dest, ValueT const& val, mpl::true_)
;
};
}
}
}}
namespace boost {
template< typename T > struct add_const { public: typedef T const type; };
template< typename T > struct add_const<T&> { public: typedef T& type; };
}
namespace boost { namespace spirit {
namespace classic {
template <typename T = nil_t>
class match : public safe_bool<match<T> >
{
public:
typedef typename boost::optional<T> optional_type;
typedef typename optional_type::argument_type ctor_param_t;
typedef typename optional_type::reference_const_type return_t;
typedef T attr_t;
match();
explicit match(std::size_t length);
match(std::size_t length, ctor_param_t val);
bool operator!() const;
std::ptrdiff_t length() const;
bool has_valid_attribute() const;
return_t value() const;
void swap(match& other);
template <typename T2>
match(match<T2> const& other)
;
template <typename T2>
match&
operator=(match<T2> const& other)
;
template <typename MatchT>
void
concat(MatchT const& other)
;
template <typename ValueT>
void
value(ValueT const& val_)
;
bool operator_bool() const
;
private:
std::ptrdiff_t len;
optional_type val;
};
template <>
class match<nil_t> : public safe_bool<match<nil_t> >
{
public:
typedef nil_t attr_t;
typedef nil_t return_t;
match();
explicit match(std::size_t length);
match(std::size_t length, nil_t);
bool operator!() const;
bool has_valid_attribute() const;
std::ptrdiff_t length() const;
nil_t value() const;
void value(nil_t);
void swap(match& other);
template <typename T>
match(match<T> const& other) ;
template <typename T>
match<>&
operator=(match<T> const& other)
;
template <typename T>
void
concat(match<T> const& other)
;
bool operator_bool() const
;
private:
std::ptrdiff_t len;
};
}
}}
namespace boost { namespace spirit {
namespace classic {
}
}}
namespace boost { namespace spirit {
namespace classic {
class parser_id
{
public:
parser_id() ;
explicit parser_id(void const* prule) ;
parser_id(std::size_t l_) ;
bool operator==(parser_id const& x) const ;
bool operator!=(parser_id const& x) const ;
bool operator<(parser_id const& x) const ;
std::size_t to_long() const ;
private:
union
{
void const* p;
std::size_t l;
};
};
struct parser_tag_base {};
struct parser_address_tag : parser_tag_base
{
parser_id id() const
;
};
template <int N>
struct parser_tag : parser_tag_base
{
static parser_id id()
;
};
class dynamic_parser_tag : public parser_tag_base
{
public:
dynamic_parser_tag() ;
parser_id
id() const
;
void set_id(parser_id id_) ;
private:
parser_id tag;
};
}
}}
namespace boost
{
namespace detail
{
using std::iterator_traits;
using std::distance;
}
}
namespace boost { namespace spirit {
namespace classic {
struct iteration_policy;
struct action_policy;
struct match_policy;
template <
typename IterationPolicyT = iteration_policy,
typename MatchPolicyT = match_policy,
typename ActionPolicyT = action_policy>
struct scanner_policies;
template <
typename IteratorT = char const*,
typename PoliciesT = scanner_policies<> >
class scanner;
}
}}
namespace boost { namespace spirit {
namespace classic {
struct iteration_policy
{
template <typename ScannerT>
void
advance(ScannerT const& scan) const
;
template <typename ScannerT>
bool at_end(ScannerT const& scan) const
;
template <typename T>
T filter(T ch) const
;
template <typename ScannerT>
typename ScannerT::ref_t
get(ScannerT const& scan) const
;
};
struct match_policy
{
template <typename T>
struct result { typedef match<T> type; };
const match<nil_t>
no_match() const
;
const match<nil_t>
empty_match() const
;
template <typename AttrT, typename IteratorT>
match<AttrT>
create_match(
std::size_t length,
AttrT const& val,
IteratorT const& ,
IteratorT const& ) const
;
template <typename MatchT, typename IteratorT>
void group_match(
MatchT& ,
parser_id const& ,
IteratorT const& ,
IteratorT const& ) const ;
template <typename Match1T, typename Match2T>
void concat_match(Match1T& l, Match2T const& r) const
;
};
template <typename MatchPolicyT, typename T>
struct match_result
{
typedef typename MatchPolicyT::template result<T>::type type;
};
template <typename AttrT>
struct attributed_action_policy
{
template <typename ActorT, typename IteratorT>
static void
call(
ActorT const& actor,
AttrT& val,
IteratorT const&,
IteratorT const&)
;
};
template <>
struct attributed_action_policy<nil_t>
{
template <typename ActorT, typename IteratorT>
static void
call(
ActorT const& actor,
nil_t,
IteratorT const& first,
IteratorT const& last)
;
};
struct action_policy
{
template <typename ActorT, typename AttrT, typename IteratorT>
void
do_action(
ActorT const& actor,
AttrT& val,
IteratorT const& first,
IteratorT const& last) const
;
};
template <
typename IterationPolicyT,
typename MatchPolicyT,
typename ActionPolicyT>
struct scanner_policies :
public IterationPolicyT,
public MatchPolicyT,
public ActionPolicyT
{
typedef IterationPolicyT iteration_policy_t;
typedef MatchPolicyT match_policy_t;
typedef ActionPolicyT action_policy_t;
scanner_policies(
IterationPolicyT const& i_policy = IterationPolicyT(),
MatchPolicyT const& m_policy = MatchPolicyT(),
ActionPolicyT const& a_policy = ActionPolicyT()) ;
template <typename ScannerPoliciesT>
scanner_policies(ScannerPoliciesT const& policies) ;
};
struct scanner_base {};
template <
typename IteratorT,
typename PoliciesT>
class scanner : public PoliciesT, public scanner_base
{
public:
typedef IteratorT iterator_t;
typedef PoliciesT policies_t;
typedef typename boost::detail::
iterator_traits<IteratorT>::value_type value_t;
typedef typename boost::detail::
iterator_traits<IteratorT>::reference ref_t;
typedef typename boost::
call_traits<IteratorT>::param_type iter_param_t;
scanner(
IteratorT& first_,
iter_param_t last_,
PoliciesT const& policies = PoliciesT())
;
scanner(scanner const& other) ;
scanner(scanner const& other, IteratorT& first_) ;
template <typename PoliciesT1>
scanner(scanner<IteratorT, PoliciesT1> const& other) ;
bool
at_end() const
;
value_t
operator*() const
;
scanner const&
operator++() const
;
template <typename PoliciesT2>
struct rebind_policies
{
typedef scanner<IteratorT, PoliciesT2> type;
};
template <typename PoliciesT2>
scanner<IteratorT, PoliciesT2>
change_policies(PoliciesT2 const& policies) const
;
template <typename IteratorT2>
struct rebind_iterator
{
typedef scanner<IteratorT2, PoliciesT> type;
};
template <typename IteratorT2>
scanner<IteratorT2, PoliciesT>
change_iterator(IteratorT2 const& first_, IteratorT2 const &last_) const
;
IteratorT& first;
IteratorT const last;
private:
scanner&
operator=(scanner const& other);
};
template <typename ScannerT, typename PoliciesT>
struct rebind_scanner_policies
{
typedef typename ScannerT::template
rebind_policies<PoliciesT>::type type;
};
template <typename ScannerT, typename IteratorT>
struct rebind_scanner_iterator
{
typedef typename ScannerT::template
rebind_iterator<IteratorT>::type type;
};
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename ParserT, typename ActionT>
class action;
struct plain_parser_category {};
struct binary_parser_category : plain_parser_category {};
struct unary_parser_category : plain_parser_category {};
struct action_parser_category : unary_parser_category {};
template <typename ParserT, typename ScannerT>
struct parser_result
{
typedef typename boost::remove_reference<ParserT>::type parser_type;
typedef typename parser_type::template result<ScannerT>::type type;
};
template <typename DerivedT>
struct parser
{
typedef DerivedT embed_t;
typedef DerivedT derived_t;
typedef plain_parser_category parser_category_t;
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, nil_t>::type type;
};
DerivedT& derived()
;
DerivedT const& derived() const
;
template <typename ActionT>
action<DerivedT, ActionT>
operator[](ActionT const& actor) const
;
};
template <typename IteratorT = char const*>
struct parse_info
{
IteratorT stop;
bool hit;
bool full;
std::size_t length;
parse_info(
IteratorT const& stop_ = IteratorT(),
bool hit_ = false,
bool full_ = false,
std::size_t length_ = 0) ;
template <typename ParseInfoT>
parse_info(ParseInfoT const& pi) ;
};
template <typename IteratorT, typename DerivedT>
parse_info<IteratorT>
parse(
IteratorT const& first,
IteratorT const& last,
parser<DerivedT> const& p);
template <typename CharT, typename DerivedT>
parse_info<CharT const*>
parse(
CharT const* str,
parser<DerivedT> const& p);
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename IteratorT, typename DerivedT>
parse_info<IteratorT>
parse(
IteratorT const& first_
, IteratorT const& last
, parser<DerivedT> const& p)
;
template <typename CharT, typename DerivedT>
parse_info<CharT const*>
parse(CharT const* str, parser<DerivedT> const& p)
;
}
}}
namespace boost
{
namespace spirit
{
namespace classic {
struct default_parser_context_base
{
template <typename DerivedT>
struct aux {};
};
struct parser_context_base {};
struct nil_t;
template<typename ContextT> struct parser_context_linker;
template<typename AttrT = nil_t>
struct parser_context : parser_context_base
{
typedef AttrT attr_t;
typedef default_parser_context_base base_t;
typedef parser_context_linker<parser_context<AttrT> > context_linker_t;
template <typename ParserT>
parser_context(ParserT const&) ;
template <typename ParserT, typename ScannerT>
void
pre_parse(ParserT const&, ScannerT const&) ;
template <typename ResultT, typename ParserT, typename ScannerT>
ResultT&
post_parse(ResultT& hit, ParserT const&, ScannerT const&)
;
};
template <typename ContextT, typename DerivedT>
struct context_aux : public ContextT::base_t::template aux<DerivedT> {};
template<typename ScannerT>
struct parser_scanner_linker : public ScannerT
{
parser_scanner_linker(ScannerT const scan_) ;
};
template<typename ContextT>
struct parser_context_linker : public ContextT
{
template <typename ParserT>
parser_context_linker(ParserT const& p) ;
template <typename ParserT, typename ScannerT>
void pre_parse(ParserT const& p, ScannerT const& scan)
;
template <typename ResultT, typename ParserT, typename ScannerT>
ResultT&
post_parse(ResultT& hit, ParserT const& p, ScannerT const& scan)
;
};
}
}
}
namespace boost { namespace spirit {
namespace classic {
namespace impl
{
template <typename BaseT, typename DefaultT
, typename T0, typename T1, typename T2>
struct get_param
{
typedef typename mpl::if_<
is_base_and_derived<BaseT, T0>
, T0
, typename mpl::if_<
is_base_and_derived<BaseT, T1>
, T1
, typename mpl::if_<
is_base_and_derived<BaseT, T2>
, T2
, DefaultT
>::type
>::type
>::type type;
};
template <typename T0, typename T1, typename T2>
struct get_context
{
typedef typename get_param<
parser_context_base, parser_context<>, T0, T1, T2>::type
type;
};
template <typename T0, typename T1, typename T2>
struct get_tag
{
typedef typename get_param<
parser_tag_base, parser_address_tag, T0, T1, T2>::type
type;
};
template <typename T0, typename T1, typename T2>
struct get_scanner
{
typedef typename get_param<
scanner_base, scanner<>, T0, T1, T2>::type
type;
};
template <
typename DerivedT
, typename EmbedT
, typename T0 = nil_t
, typename T1 = nil_t
, typename T2 = nil_t
>
class rule_base;
class rule_base_access
{
template <
typename DerivedT
, typename EmbedT
, typename T0
, typename T1
, typename T2
>
friend class rule_base;
template <typename RuleT>
static typename RuleT::abstract_parser_t*
get(RuleT const& r)
;
};
template <
typename DerivedT
, typename EmbedT
, typename T0
, typename T1
, typename T2
>
class rule_base
: public parser<DerivedT>
, public impl::get_context<T0, T1, T2>::type::base_t
, public context_aux<
typename impl::get_context<T0, T1, T2>::type, DerivedT>
, public impl::get_tag<T0, T1, T2>::type
{
public:
typedef typename impl::get_scanner<T0, T1, T2>::type scanner_t;
typedef typename impl::get_context<T0, T1, T2>::type context_t;
typedef typename impl::get_tag<T0, T1, T2>::type tag_t;
typedef EmbedT embed_t;
typedef typename context_t::context_linker_t linked_context_t;
typedef typename linked_context_t::attr_t attr_t;
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, attr_t>::type type;
};
template <typename ScannerT>
typename parser_result<DerivedT, ScannerT>::type
parse(ScannerT const& scan) const
;
template <typename ScannerT>
typename parser_result<DerivedT, ScannerT>::type
parse_main(ScannerT const& scan) const
;
};
template <typename ScannerT, typename AttrT>
struct abstract_parser
{
abstract_parser() ;
virtual ~abstract_parser() ;
virtual typename match_result<ScannerT, AttrT>::type
do_parse_virtual(ScannerT const& scan) const = 0;
virtual abstract_parser*
clone() const = 0;
};
template <typename ParserT, typename ScannerT, typename AttrT>
struct concrete_parser : abstract_parser<ScannerT, AttrT>
{
concrete_parser(ParserT const& p_) ;
virtual ~concrete_parser() ;
virtual typename match_result<ScannerT, AttrT>::type
do_parse_virtual(ScannerT const& scan) const
;
virtual abstract_parser<ScannerT, AttrT>*
clone() const
;
typename ParserT::embed_t p;
};
}
}
}}
namespace boost { namespace spirit {
namespace classic {
template <
typename T0 = nil_t
, typename T1 = nil_t
, typename T2 = nil_t
>
class rule
: public impl::rule_base<
rule<T0, T1, T2>
, rule<T0, T1, T2> const&
, T0, T1, T2>
{
public:
typedef rule<T0, T1, T2> self_t;
typedef impl::rule_base<
self_t
, self_t const&
, T0, T1, T2>
base_t;
typedef typename base_t::scanner_t scanner_t;
typedef typename base_t::attr_t attr_t;
typedef impl::abstract_parser<scanner_t, attr_t> abstract_parser_t;
rule() ;
~rule() ;
rule(rule const& r) ;
template <typename ParserT>
rule(ParserT const& p) ;
template <typename ParserT>
rule& operator=(ParserT const& p)
;
rule& operator=(rule const& r)
;
rule<T0, T1, T2>
copy() const
;
private:
friend class impl::rule_base_access;
abstract_parser_t*
get() const
;
rule(abstract_parser_t* ptr_) ;
rule(abstract_parser_t const* ptr_) ;
scoped_ptr<abstract_parser_t> ptr;
};
}
}}
namespace boost
{
class bad_weak_ptr: public std::exception
{
public:
virtual char const * what() const throw()
;
};
}
namespace __cxxabiv1
{
extern "C"
{
__extension__ typedef int __guard __attribute__((mode (__DI__)));
typedef void __cxa_vec_ctor_return_type;
typedef void __cxa_cdtor_return_type;
}
}
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) throw();
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*) throw();
void
__cxa_guard_abort(__guard*) throw();
int
__cxa_atexit(void (*)(void*), void*, void*) throw();
int
__cxa_finalize(void*);
int
__cxa_thread_atexit(void (*)(void*), void*, void *) throw();
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__));
void
__cxa_throw_bad_array_new_length() __attribute__((__noreturn__));
char*
__cxa_demangle(const char* __mangled_name, char* __output_buffer,
size_t* __length, int* __status);
}
}
extern "C++" {
namespace __cxxabiv1
{
class __class_type_info;
}
namespace std
{
class type_info
{
public:
virtual ~type_info();
const char* name() const
;
bool before(const type_info& __arg) const
;
bool operator==(const type_info& __arg) const
;
bool operator!=(const type_info& __arg) const
;
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) ;
private:
type_info& operator=(const type_info&);
type_info(const type_info&);
};
class bad_cast : public exception
{
public:
bad_cast() throw() ;
virtual ~bad_cast() throw();
virtual const char* what() const throw();
};
class bad_typeid : public exception
{
public:
bad_typeid () throw() ;
virtual ~bad_typeid() throw();
virtual const char* what() const throw();
};
}
}
namespace __cxxabiv1
{
class __fundamental_type_info : public std::type_info
{
public:
explicit
__fundamental_type_info(const char* __n) ;
virtual
~__fundamental_type_info();
};
class __array_type_info : public std::type_info
{
public:
explicit
__array_type_info(const char* __n) ;
virtual
~__array_type_info();
};
class __function_type_info : public std::type_info
{
public:
explicit
__function_type_info(const char* __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) ;
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)
;
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) ;
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) ;
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
;
bool
__is_public_p() const
;
ptrdiff_t
__offset() const
;
};
class __class_type_info : public std::type_info
{
public:
explicit
__class_type_info (const char *__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;
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) ;
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) ;
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"
{
void*
__dynamic_cast(const void* __src_ptr,
const __class_type_info* __src_type,
const __class_type_info* __dst_type,
ptrdiff_t __src2dst);
__cxa_eh_globals*
__cxa_get_globals() throw() __attribute__ ((__const__));
__cxa_eh_globals*
__cxa_get_globals_fast() throw() __attribute__ ((__const__));
void*
__cxa_allocate_exception(size_t) throw();
void
__cxa_free_exception(void*) throw();
void
__cxa_throw(void*, std::type_info*, void ( *) (void *))
__attribute__((__noreturn__));
void*
__cxa_get_exception_ptr(void*) throw() __attribute__ ((__pure__));
void*
__cxa_begin_catch(void*) throw();
void
__cxa_end_catch();
void
__cxa_rethrow() __attribute__((__noreturn__));
std::type_info*
__cxa_current_exception_type() throw() __attribute__ ((__pure__));
__cxa_dependent_exception*
__cxa_allocate_dependent_exception() throw();
void
__cxa_free_dependent_exception(__cxa_dependent_exception*) throw();
}
class __foreign_exception
{
virtual ~__foreign_exception() throw();
virtual void __pure_dummy() = 0;
};
}
namespace abi = __cxxabiv1;
namespace __gnu_cxx
{
class recursive_init_error: public std::exception
{
public:
recursive_init_error() throw() ;
virtual ~recursive_init_error() throw ();
};
}
namespace boost
{
namespace core
{
char const * demangle_alloc( char const * name ) ;
void demangle_free( char const * name ) ;
class scoped_demangled_name
{
private:
char const * m_p;
public:
explicit scoped_demangled_name( char const * name )
;
~scoped_demangled_name()
;
char const * get() const
;
private:
scoped_demangled_name( scoped_demangled_name const& )
;
private:
scoped_demangled_name& operator= ( scoped_demangled_name const& )
;
};
char const * demangle_alloc( char const * name )
;
void demangle_free( char const * name )
;
std::string demangle( char const * name )
;
}
}
namespace boost
{
namespace core
{
typedef std::type_info typeinfo;
std::string demangled_name( core::typeinfo const & ti )
;
}
}
namespace boost
{
namespace detail
{
typedef boost::core::typeinfo sp_typeinfo;
}
}
namespace boost
{
namespace detail
{
int atomic_exchange_and_add( int * pw, int dv )
;
void atomic_increment( int * pw )
;
int atomic_conditional_increment( int * pw )
;
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()
;
virtual ~sp_counted_base()
;
virtual void dispose() = 0;
virtual void destroy()
;
virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
virtual void * get_untyped_deleter() = 0;
void add_ref_copy()
;
bool add_ref_lock()
;
void release()
;
void weak_add_ref()
;
void weak_release()
;
long use_count() const
;
};
}
}
namespace boost
{
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 )
;
virtual void dispose()
;
virtual void * get_deleter( sp_typeinfo const & )
;
virtual void * get_untyped_deleter()
;
};
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 )
;
sp_counted_impl_pd( P p )
;
virtual void dispose()
;
virtual void * get_deleter( sp_typeinfo const & ti )
;
virtual void * get_untyped_deleter()
;
};
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 )
;
sp_counted_impl_pda( P p, A a )
;
virtual void dispose()
;
virtual void destroy()
;
virtual void * get_deleter( sp_typeinfo const & ti )
;
virtual void * get_untyped_deleter()
;
};
}
}
namespace boost
{
namespace detail
{
struct sp_nothrow_tag {};
template< class D > struct sp_inplace_tag
{
};
class weak_count;
class shared_count
{
private:
sp_counted_base * pi_;
friend class weak_count;
public:
shared_count()
;
template<class Y> explicit shared_count( Y * p )
;
template<class P, class D> shared_count( P p, D d )
;
template< class P, class D > shared_count( P p, sp_inplace_tag<D> )
;
template<class P, class D, class A> shared_count( P p, D d, A a )
;
template< class P, class D, class A > shared_count( P p, sp_inplace_tag< D >, A a )
;
template<class Y>
explicit shared_count( std::auto_ptr<Y> & r )
;
~shared_count()
;
shared_count(shared_count const & r)
;
explicit shared_count(weak_count const & r);
shared_count( weak_count const & r, sp_nothrow_tag );
shared_count & operator= (shared_count const & r)
;
void swap(shared_count & r)
;
long use_count() const
;
bool unique() const
;
bool empty() const
;
friend bool operator==(shared_count const & a, shared_count const & b)
;
friend bool operator<(shared_count const & a, shared_count const & b)
;
void * get_deleter( sp_typeinfo const & ti ) const
;
void * get_untyped_deleter() const
;
};
class weak_count
{
private:
sp_counted_base * pi_;
friend class shared_count;
public:
weak_count()
;
weak_count(shared_count const & r)
;
weak_count(weak_count const & r)
;
~weak_count()
;
weak_count & operator= (shared_count const & r)
;
weak_count & operator= (weak_count const & r)
;
void swap(weak_count & r)
;
long use_count() const
;
bool empty() const
;
friend bool operator==(weak_count const & a, weak_count const & b)
;
friend bool operator<(weak_count const & a, weak_count const & b)
;
};
}
}
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 >
{
};
}
}
namespace boost
{
namespace detail
{
void yield( unsigned k )
;
}
}
namespace boost
{
namespace detail
{
class spinlock
{
public:
int v_;
public:
bool try_lock()
;
void lock()
;
void unlock()
;
public:
class scoped_lock
{
private:
spinlock & sp_;
scoped_lock( scoped_lock const & );
scoped_lock & operator=( scoped_lock const & );
public:
explicit scoped_lock( spinlock & sp )
;
~scoped_lock()
;
};
};
}
}
namespace boost
{
namespace detail
{
template< int M > class spinlock_pool
{
private:
static spinlock pool_[ 41 ];
public:
static spinlock & spinlock_for( void const * pv )
;
class scoped_lock
{
private:
spinlock & sp_;
scoped_lock( scoped_lock const & );
scoped_lock & operator=( scoped_lock const & );
public:
explicit scoped_lock( void const * pv )
;
~scoped_lock()
;
};
};
template< int M > spinlock spinlock_pool< M >::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}
};
}
}
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 > void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
;
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 );
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 > void sp_assert_convertible()
;
template< class T, class Y > void sp_pointer_construct( boost::shared_ptr< T > * ppx, Y * p, boost::detail::shared_count & pn )
;
template< class T, class Y > void sp_pointer_construct( boost::shared_ptr< T[] > * , Y * p, boost::detail::shared_count & pn )
;
template< class T, std::size_t N, class Y > void sp_pointer_construct( boost::shared_ptr< T[N] > * , Y * p, boost::detail::shared_count & pn )
;
template< class T, class Y > void sp_deleter_construct( boost::shared_ptr< T > * ppx, Y * p )
;
template< class T, class Y > void sp_deleter_construct( boost::shared_ptr< T[] > * , Y * )
;
template< class T, std::size_t N, class Y > void sp_deleter_construct( boost::shared_ptr< T[N] > * , Y * )
;
}
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()
;
template<class Y>
explicit shared_ptr( Y * p )
;
template<class Y, class D> shared_ptr( Y * p, D d )
;
template<class Y, class D, class A> shared_ptr( Y * p, D d, A a )
;
template<class Y>
explicit shared_ptr( weak_ptr<Y> const & r )
;
template<class Y>
shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag )
;
template<class Y>
shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
;
template< class Y >
shared_ptr( shared_ptr<Y> const & r, element_type * p )
;
template<class Y>
explicit shared_ptr( std::auto_ptr<Y> & r )
;
template<class Ap>
explicit shared_ptr( Ap r, typename boost::detail::sp_enable_if_auto_ptr<Ap, int>::type = 0 )
;
shared_ptr & operator=( shared_ptr const & r )
;
template<class Y>
shared_ptr & operator=(shared_ptr<Y> const & r)
;
template<class Y>
shared_ptr & operator=( std::auto_ptr<Y> & r )
;
template<class Ap>
typename boost::detail::sp_enable_if_auto_ptr< Ap, shared_ptr & >::type operator=( Ap r )
;
void reset()
;
template<class Y> void reset( Y * p )
;
template<class Y, class D> void reset( Y * p, D d )
;
template<class Y, class D, class A> void reset( Y * p, D d, A a )
;
template<class Y> void reset( shared_ptr<Y> const & r, element_type * p )
;
typename boost::detail::sp_dereference< T >::type operator* () const
;
typename boost::detail::sp_member_access< T >::type operator-> () const
;
typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const
;
element_type * get() const
;
typedef element_type * this_type::*unspecified_bool_type;
operator unspecified_bool_type() const
;
bool operator! () const
;
bool unique() const
;
long use_count() const
;
void swap( shared_ptr & other )
;
template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const
;
template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const
;
void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const
;
void * _internal_get_untyped_deleter() const
;
bool _internal_equiv( shared_ptr const & r ) const
;
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> bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
;
template<class T, class U> bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
;
template<class T, class U> bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
;
template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b)
;
template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> const & r )
;
template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> const & r )
;
template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> const & r )
;
template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> const & r )
;
template<class T> typename shared_ptr<T>::element_type * get_pointer(shared_ptr<T> const & p)
;
template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
;
namespace detail
{
template<class D, class T> D * basic_get_deleter( shared_ptr<T> const & p )
;
class esft2_deleter_wrapper
{
private:
shared_ptr<void const volatile> deleter_;
public:
esft2_deleter_wrapper()
;
template< class T > void set_deleter( shared_ptr<T> const & deleter )
;
template<typename D> D* get_deleter() const
;
template< class T> void operator()( T* )
;
};
}
template<class D, class T> D * get_deleter( shared_ptr<T> const & p )
;
template<class T> bool atomic_is_lock_free( shared_ptr<T> const * )
;
template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
;
template<class T> shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, int )
;
template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
;
template<class T> void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, int )
;
template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
;
template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, int )
;
template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
;
template<class T> bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, int, int )
;
template< class T > struct hash;
template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p )
;
}
namespace boost
{
template<class T> class reference_wrapper
{
public:
typedef T type;
__attribute__ ((__always_inline__))
explicit reference_wrapper(T& t) ;
__attribute__ ((__always_inline__))
operator T& () const ;
__attribute__ ((__always_inline__))
T& get() const ;
__attribute__ ((__always_inline__))
T* get_pointer() const ;
private:
T* t_;
};
template<class T>
__attribute__ ((__always_inline__))
reference_wrapper<T> const ref( T & t )
;
template<class T>
__attribute__ ((__always_inline__))
reference_wrapper<T const> const cref( T const & t )
;
template<typename T> struct is_reference_wrapper
{
static const
bool value = false;
};
template<typename T> struct is_reference_wrapper< reference_wrapper<T> >
{
static const
bool value = true;
};
template<typename T> struct is_reference_wrapper< reference_wrapper<T> const >
{
static const
bool value = true;
};
template<typename T> struct is_reference_wrapper< reference_wrapper<T> volatile >
{
static const
bool value = true;
};
template<typename T> struct is_reference_wrapper< reference_wrapper<T> const volatile >
{
static const
bool value = true;
};
template<typename T> struct unwrap_reference
{
typedef T type;
};
template<typename T> struct unwrap_reference< reference_wrapper<T> >
{
typedef T type;
};
template<typename T> struct unwrap_reference< reference_wrapper<T> const >
{
typedef T type;
};
template<typename T> struct unwrap_reference< reference_wrapper<T> volatile >
{
typedef T type;
};
template<typename T> struct unwrap_reference< reference_wrapper<T> const volatile >
{
typedef T type;
};
template<class T>
__attribute__ ((__always_inline__))
typename unwrap_reference<T>::type& unwrap_ref( T & t )
;
template<class T>
__attribute__ ((__always_inline__))
T* get_pointer( reference_wrapper<T> const & r )
;
}
namespace boost { namespace spirit {
namespace classic {
template <typename DrivedT> struct char_parser;
namespace impl
{
template <typename IteratorT>
IteratorT
get_last(IteratorT first)
;
template<
typename RT,
typename IteratorT,
typename ScannerT>
RT
string_parser_parse(
IteratorT str_first,
IteratorT str_last,
ScannerT& scan)
;
template <typename CharT>
struct char_type_char_traits_helper
{
typedef CharT char_type;
typedef typename std::char_traits<CharT>::int_type int_type;
static int_type to_int_type(CharT c)
;
static char_type to_char_type(int_type i)
;
};
template <typename CharT>
struct char_traits_helper
{
typedef CharT char_type;
typedef CharT int_type;
static CharT & to_int_type(CharT & c)
;
static CharT & to_char_type(CharT & c)
;
};
template <>
struct char_traits_helper<char>
: char_type_char_traits_helper<char>
{
};
template <>
struct char_traits_helper<wchar_t>
: char_type_char_traits_helper<wchar_t>
{
};
template <typename CharT>
typename char_traits_helper<CharT>::int_type
to_int_type(CharT c)
;
template <typename CharT>
CharT
to_char_type(typename char_traits_helper<CharT>::int_type c)
;
template <typename CharT>
bool
isalnum_(CharT c)
;
template <typename CharT>
bool
isalpha_(CharT c)
;
template <typename CharT>
bool
iscntrl_(CharT c)
;
template <typename CharT>
bool
isdigit_(CharT c)
;
template <typename CharT>
bool
isgraph_(CharT c)
;
template <typename CharT>
bool
islower_(CharT c)
;
template <typename CharT>
bool
isprint_(CharT c)
;
template <typename CharT>
bool
ispunct_(CharT c)
;
template <typename CharT>
bool
isspace_(CharT c)
;
template <typename CharT>
bool
isupper_(CharT c)
;
template <typename CharT>
bool
isxdigit_(CharT c)
;
template <typename CharT>
bool
isblank_(CharT c)
;
template <typename CharT>
CharT
tolower_(CharT c)
;
template <typename CharT>
CharT
toupper_(CharT c)
;
bool
isalnum_(wchar_t c)
;
bool
isalpha_(wchar_t c)
;
bool
iscntrl_(wchar_t c)
;
bool
isdigit_(wchar_t c)
;
bool
isgraph_(wchar_t c)
;
bool
islower_(wchar_t c)
;
bool
isprint_(wchar_t c)
;
bool
ispunct_(wchar_t c)
;
bool
isspace_(wchar_t c)
;
bool
isupper_(wchar_t c)
;
bool
isxdigit_(wchar_t c)
;
bool
isblank_(wchar_t c)
;
wchar_t
tolower_(wchar_t c)
;
wchar_t
toupper_(wchar_t c)
;
}
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename BaseT = iteration_policy>
struct skipper_iteration_policy;
template <typename BaseT = iteration_policy>
struct no_skipper_iteration_policy;
template <typename ParserT, typename BaseT = iteration_policy>
class skip_parser_iteration_policy;
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename BaseT>
struct skipper_iteration_policy : public BaseT
{
typedef BaseT base_t;
skipper_iteration_policy() ;
template <typename PolicyT>
skipper_iteration_policy(PolicyT const& other) ;
template <typename ScannerT>
void
advance(ScannerT const& scan) const
;
template <typename ScannerT>
bool
at_end(ScannerT const& scan) const
;
template <typename ScannerT>
void
skip(ScannerT const& scan) const
;
};
template <typename BaseT>
struct no_skipper_iteration_policy : public BaseT
{
typedef BaseT base_t;
no_skipper_iteration_policy() ;
template <typename PolicyT>
no_skipper_iteration_policy(PolicyT const& other) ;
template <typename ScannerT>
void
skip(ScannerT const& ) const ;
};
namespace impl
{
template <typename ST, typename ScannerT, typename BaseT>
void
skipper_skip(
ST const& s,
ScannerT const& scan,
skipper_iteration_policy<BaseT> const&);
template <typename ST, typename ScannerT, typename BaseT>
void
skipper_skip(
ST const& s,
ScannerT const& scan,
no_skipper_iteration_policy<BaseT> const&);
template <typename ST, typename ScannerT>
void
skipper_skip(
ST const& s,
ScannerT const& scan,
iteration_policy const&);
}
template <typename ParserT, typename BaseT>
class skip_parser_iteration_policy : public skipper_iteration_policy<BaseT>
{
public:
typedef skipper_iteration_policy<BaseT> base_t;
skip_parser_iteration_policy(
ParserT const& skip_parser,
base_t const& base = base_t()) ;
template <typename PolicyT>
skip_parser_iteration_policy(PolicyT const& other) ;
template <typename ScannerT>
void
skip(ScannerT const& scan) const
;
ParserT const&
skipper() const
;
private:
ParserT const& subject;
};
template <typename IteratorT, typename ParserT, typename SkipT>
parse_info<IteratorT>
parse(
IteratorT const& first,
IteratorT const& last,
parser<ParserT> const& p,
parser<SkipT> const& skip);
template <typename CharT, typename ParserT, typename SkipT>
parse_info<CharT const*>
parse(
CharT const* str,
parser<ParserT> const& p,
parser<SkipT> const& skip);
typedef skipper_iteration_policy<> iter_policy_t;
typedef scanner_policies<iter_policy_t> scanner_policies_t;
typedef scanner<char const*, scanner_policies_t> phrase_scanner_t;
typedef scanner<wchar_t const*, scanner_policies_t> wide_phrase_scanner_t;
}
}}
namespace boost { namespace spirit {
namespace classic {
struct space_parser;
template <typename BaseT>
struct no_skipper_iteration_policy;
namespace impl
{
template <typename ST, typename ScannerT, typename BaseT>
void
skipper_skip(
ST const& s,
ScannerT const& scan,
skipper_iteration_policy<BaseT> const&)
;
template <typename ST, typename ScannerT, typename BaseT>
void
skipper_skip(
ST const& s,
ScannerT const& scan,
no_skipper_iteration_policy<BaseT> const&)
;
template <typename ST, typename ScannerT>
void
skipper_skip(
ST const& s,
ScannerT const& scan,
iteration_policy const&)
;
template <typename SkipT>
struct phrase_parser
{
template <typename IteratorT, typename ParserT>
static parse_info<IteratorT>
parse(
IteratorT const& first_,
IteratorT const& last,
ParserT const& p,
SkipT const& skip)
;
};
template <>
struct phrase_parser<space_parser>
{
template <typename IteratorT, typename ParserT>
static parse_info<IteratorT>
parse(
IteratorT const& first_,
IteratorT const& last,
ParserT const& p,
space_parser const&)
;
};
}
template <typename IteratorT, typename ParserT, typename SkipT>
parse_info<IteratorT>
parse(
IteratorT const& first,
IteratorT const& last,
parser<ParserT> const& p,
parser<SkipT> const& skip)
;
template <typename CharT, typename ParserT, typename SkipT>
parse_info<CharT const*>
parse(
CharT const* str,
parser<ParserT> const& p,
parser<SkipT> const& skip)
;
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename BaseT>
struct no_skipper_iteration_policy;
template <typename BaseT>
struct inhibit_case_iteration_policy;
template <typename A, typename B>
struct alternative;
template <typename A, typename B>
struct longest_alternative;
template <typename A, typename B>
struct shortest_alternative;
namespace impl
{
template <typename RT, typename ST, typename ScannerT, typename BaseT>
RT
contiguous_parser_parse(
ST const& s,
ScannerT const& scan,
skipper_iteration_policy<BaseT> const&)
;
template <typename RT, typename ST, typename ScannerT, typename BaseT>
RT
contiguous_parser_parse(
ST const& s,
ScannerT const& scan,
no_skipper_iteration_policy<BaseT> const&)
;
template <typename RT, typename ST, typename ScannerT>
RT
contiguous_parser_parse(
ST const& s,
ScannerT const& scan,
iteration_policy const&)
;
template <
typename RT,
typename ParserT,
typename ScannerT,
typename BaseT>
RT
implicit_lexeme_parse(
ParserT const& p,
ScannerT const& scan,
skipper_iteration_policy<BaseT> const&)
;
template <
typename RT,
typename ParserT,
typename ScannerT,
typename BaseT>
RT
implicit_lexeme_parse(
ParserT const& p,
ScannerT const& scan,
no_skipper_iteration_policy<BaseT> const&)
;
template <typename RT, typename ParserT, typename ScannerT>
RT
implicit_lexeme_parse(
ParserT const& p,
ScannerT const& scan,
iteration_policy const&)
;
template <typename RT, typename ST, typename ScannerT>
RT
inhibit_case_parser_parse(
ST const& s,
ScannerT const& scan,
iteration_policy const&)
;
template <typename RT, typename ST, typename ScannerT, typename BaseT>
RT
inhibit_case_parser_parse(
ST const& s,
ScannerT const& scan,
inhibit_case_iteration_policy<BaseT> const&)
;
template <typename T>
struct to_longest_alternative
{
typedef T result_t;
static result_t const&
convert(T const& a)
;
};
template <typename A, typename B>
struct to_longest_alternative<alternative<A, B> >
{
typedef typename to_longest_alternative<A>::result_t a_t;
typedef typename to_longest_alternative<B>::result_t b_t;
typedef longest_alternative<a_t, b_t> result_t;
static result_t
convert(alternative<A, B> const& alt)
;
};
template <typename T>
struct to_shortest_alternative
{
typedef T result_t;
static result_t const&
convert(T const& a)
;
};
template <typename A, typename B>
struct to_shortest_alternative<alternative<A, B> >
{
typedef typename to_shortest_alternative<A>::result_t a_t;
typedef typename to_shortest_alternative<B>::result_t b_t;
typedef shortest_alternative<a_t, b_t> result_t;
static result_t
convert(alternative<A, B> const& alt)
;
};
}
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename DerivedT>
struct char_parser : public parser<DerivedT>
{
typedef DerivedT self_t;
template <typename ScannerT>
struct result
{
typedef typename match_result<
ScannerT,
typename ScannerT::value_t
>::type type;
};
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
template <typename PositiveT>
struct negated_char_parser
: public char_parser<negated_char_parser<PositiveT> >
{
typedef negated_char_parser<PositiveT> self_t;
typedef PositiveT positive_t;
negated_char_parser(positive_t const& p) ;
template <typename T>
bool test(T ch) const
;
positive_t const positive;
};
template <typename ParserT>
negated_char_parser<ParserT>
operator~(char_parser<ParserT> const& p)
;
template <typename ParserT>
ParserT
operator~(negated_char_parser<ParserT> const& n)
;
template <typename CharT = char>
struct chlit : public char_parser<chlit<CharT> >
{
chlit(CharT ch_) ;
template <typename T>
bool test(T ch_) const
;
CharT ch;
};
template <typename CharT>
chlit<CharT>
ch_p(CharT ch)
;
template <typename CharT, std::size_t N>
chlit<CharT>
ch_p(CharT const (& str)[N])
;
template <typename CharT = char>
struct range : public char_parser<range<CharT> >
{
range(CharT first_, CharT last_)
;
template <typename T>
bool test(T ch) const
;
CharT first;
CharT last;
};
template <typename CharT>
range<CharT>
range_p(CharT first, CharT last)
;
template <typename IteratorT = char const*>
class chseq : public parser<chseq<IteratorT> >
{
public:
typedef chseq<IteratorT> self_t;
chseq(IteratorT first_, IteratorT last_) ;
chseq(IteratorT first_) ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
private:
IteratorT first;
IteratorT last;
};
template <typename CharT>
chseq<CharT const*>
chseq_p(CharT const* str)
;
template <typename IteratorT>
chseq<IteratorT>
chseq_p(IteratorT first, IteratorT last)
;
template <typename IteratorT = char const*>
class strlit : public parser<strlit<IteratorT> >
{
public:
typedef strlit<IteratorT> self_t;
strlit(IteratorT first, IteratorT last) ;
strlit(IteratorT first) ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
private:
chseq<IteratorT> seq;
};
template <typename CharT>
strlit<CharT const*>
str_p(CharT const* str)
;
template <typename CharT>
strlit<CharT *>
str_p(CharT * str)
;
template <typename IteratorT>
strlit<IteratorT>
str_p(IteratorT first, IteratorT last)
;
template <typename CharT>
chlit<CharT>
str_p(CharT ch)
;
struct nothing_parser : public parser<nothing_parser>
{
typedef nothing_parser self_t;
nothing_parser() ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
nothing_parser const nothing_p = nothing_parser();
struct anychar_parser : public char_parser<anychar_parser>
{
typedef anychar_parser self_t;
anychar_parser() ;
template <typename CharT>
bool test(CharT) const
;
};
anychar_parser const anychar_p = anychar_parser();
nothing_parser
operator~(anychar_parser)
;
struct alnum_parser : public char_parser<alnum_parser>
{
typedef alnum_parser self_t;
alnum_parser() ;
template <typename CharT>
bool test(CharT ch) const
;
};
alnum_parser const alnum_p = alnum_parser();
struct alpha_parser : public char_parser<alpha_parser>
{
typedef alpha_parser self_t;
alpha_parser() ;
template <typename CharT>
bool test(CharT ch) const
;
};
alpha_parser const alpha_p = alpha_parser();
struct cntrl_parser : public char_parser<cntrl_parser>
{
typedef cntrl_parser self_t;
cntrl_parser() ;
template <typename CharT>
bool test(CharT ch) const
;
};
cntrl_parser const cntrl_p = cntrl_parser();
struct digit_parser : public char_parser<digit_parser>
{
typedef digit_parser self_t;
digit_parser() ;
template <typename CharT>
bool test(CharT ch) const
;
};
digit_parser const digit_p = digit_parser();
struct graph_parser : public char_parser<graph_parser>
{
typedef graph_parser self_t;
graph_parser() ;
template <typename CharT>
bool test(CharT ch) const
;
};
graph_parser const graph_p = graph_parser();
struct lower_parser : public char_parser<lower_parser>
{
typedef lower_parser self_t;
lower_parser() ;
template <typename CharT>
bool test(CharT ch) const
;
};
lower_parser const lower_p = lower_parser();
struct print_parser : public char_parser<print_parser>
{
typedef print_parser self_t;
print_parser() ;
template <typename CharT>
bool test(CharT ch) const
;
};
print_parser const print_p = print_parser();
struct punct_parser : public char_parser<punct_parser>
{
typedef punct_parser self_t;
punct_parser() ;
template <typename CharT>
bool test(CharT ch) const
;
};
punct_parser const punct_p = punct_parser();
struct blank_parser : public char_parser<blank_parser>
{
typedef blank_parser self_t;
blank_parser() ;
template <typename CharT>
bool test(CharT ch) const
;
};
blank_parser const blank_p = blank_parser();
struct space_parser : public char_parser<space_parser>
{
typedef space_parser self_t;
space_parser() ;
template <typename CharT>
bool test(CharT ch) const
;
};
space_parser const space_p = space_parser();
struct upper_parser : public char_parser<upper_parser>
{
typedef upper_parser self_t;
upper_parser() ;
template <typename CharT>
bool test(CharT ch) const
;
};
upper_parser const upper_p = upper_parser();
struct xdigit_parser : public char_parser<xdigit_parser>
{
typedef xdigit_parser self_t;
xdigit_parser() ;
template <typename CharT>
bool test(CharT ch) const
;
};
xdigit_parser const xdigit_p = xdigit_parser();
struct eol_parser : public parser<eol_parser>
{
typedef eol_parser self_t;
eol_parser() ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
eol_parser const eol_p = eol_parser();
struct end_parser : public parser<end_parser>
{
typedef end_parser self_t;
end_parser() ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
end_parser const end_p = end_parser();
strlit<char const*> const
pizza_p(char const* your_favorite_pizza)
;
}
}}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<size_t _Nw>
struct _Base_bitset
{
typedef unsigned long _WordT;
_WordT _M_w[_Nw];
_Base_bitset() ;
_Base_bitset(unsigned long __val)
;
static size_t
_S_whichword(size_t __pos)
;
static size_t
_S_whichbyte(size_t __pos)
;
static size_t
_S_whichbit(size_t __pos)
;
static _WordT
_S_maskbit(size_t __pos)
;
_WordT&
_M_getword(size_t __pos)
;
_WordT
_M_getword(size_t __pos) const
;
_WordT&
_M_hiword()
;
_WordT
_M_hiword() const
;
void
_M_do_and(const _Base_bitset<_Nw>& __x)
;
void
_M_do_or(const _Base_bitset<_Nw>& __x)
;
void
_M_do_xor(const _Base_bitset<_Nw>& __x)
;
void
_M_do_left_shift(size_t __shift) ;
void
_M_do_right_shift(size_t __shift) ;
void
_M_do_flip()
;
void
_M_do_set()
;
void
_M_do_reset()
;
bool
_M_is_equal(const _Base_bitset<_Nw>& __x) const
;
template<size_t _Nb>
bool
_M_are_all() const
;
bool
_M_is_any() const
;
size_t
_M_do_count() const
;
unsigned long
_M_do_to_ulong() const;
size_t
_M_do_find_first(size_t) const ;
size_t
_M_do_find_next(size_t, size_t) const ;
};
template<>
struct _Base_bitset<1>
{
typedef unsigned long _WordT;
_WordT _M_w;
_Base_bitset()
;
_Base_bitset(unsigned long __val)
;
static size_t
_S_whichword(size_t __pos)
;
static size_t
_S_whichbyte(size_t __pos)
;
static size_t
_S_whichbit(size_t __pos)
;
static _WordT
_S_maskbit(size_t __pos)
;
_WordT&
_M_getword(size_t)
;
_WordT
_M_getword(size_t) const
;
_WordT&
_M_hiword()
;
_WordT
_M_hiword() const
;
void
_M_do_and(const _Base_bitset<1>& __x)
;
void
_M_do_or(const _Base_bitset<1>& __x)
;
void
_M_do_xor(const _Base_bitset<1>& __x)
;
void
_M_do_left_shift(size_t __shift)
;
void
_M_do_right_shift(size_t __shift)
;
void
_M_do_flip()
;
void
_M_do_set()
;
void
_M_do_reset()
;
bool
_M_is_equal(const _Base_bitset<1>& __x) const
;
template<size_t _Nb>
bool
_M_are_all() const
;
bool
_M_is_any() const
;
size_t
_M_do_count() const
;
unsigned long
_M_do_to_ulong() const
;
size_t
_M_do_find_first(size_t __not_found) const
;
size_t
_M_do_find_next(size_t __prev, size_t __not_found) const
;
};
template<>
struct _Base_bitset<0>
{
typedef unsigned long _WordT;
_Base_bitset()
;
_Base_bitset(unsigned long)
;
static size_t
_S_whichword(size_t __pos)
;
static size_t
_S_whichbyte(size_t __pos)
;
static size_t
_S_whichbit(size_t __pos)
;
static _WordT
_S_maskbit(size_t __pos)
;
_WordT&
_M_getword(size_t)
;
_WordT
_M_getword(size_t __pos) const
;
_WordT
_M_hiword() const
;
void
_M_do_and(const _Base_bitset<0>&)
;
void
_M_do_or(const _Base_bitset<0>&)
;
void
_M_do_xor(const _Base_bitset<0>&)
;
void
_M_do_left_shift(size_t)
;
void
_M_do_right_shift(size_t)
;
void
_M_do_flip()
;
void
_M_do_set()
;
void
_M_do_reset()
;
bool
_M_is_equal(const _Base_bitset<0>&) const
;
template<size_t _Nb>
bool
_M_are_all() const
;
bool
_M_is_any() const
;
size_t
_M_do_count() const
;
unsigned long
_M_do_to_ulong() const
;
size_t
_M_do_find_first(size_t) const
;
size_t
_M_do_find_next(size_t, size_t) const
;
};
template<size_t _Extrabits>
struct _Sanitize
{
typedef unsigned long _WordT;
static void
_S_do_sanitize(_WordT& __val)
;
};
template<>
struct _Sanitize<0>
{
typedef unsigned long _WordT;
static void
_S_do_sanitize(_WordT) ;
};
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;
template<class _CharT, class _Traits, class _Alloc>
void
_M_check_initial_position(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
size_t __position) const
;
void _M_check(size_t __position, const char *__s) const
;
void
_M_do_sanitize()
;
public:
class reference
{
friend class bitset;
_WordT* _M_wp;
size_t _M_bpos;
reference();
public:
reference(bitset& __b, size_t __pos)
;
~reference()
;
reference&
operator=(bool __x)
;
reference&
operator=(const reference& __j)
;
bool
operator~() const
;
operator bool() const
;
reference&
flip()
;
};
friend class reference;
bitset()
;
bitset(unsigned long __val)
;
template<class _CharT, class _Traits, class _Alloc>
explicit
bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
size_t __position = 0)
;
template<class _CharT, class _Traits, class _Alloc>
bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
size_t __position, size_t __n)
;
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'))
;
bitset<_Nb>&
operator&=(const bitset<_Nb>& __rhs)
;
bitset<_Nb>&
operator|=(const bitset<_Nb>& __rhs)
;
bitset<_Nb>&
operator^=(const bitset<_Nb>& __rhs)
;
bitset<_Nb>&
operator<<=(size_t __position)
;
bitset<_Nb>&
operator>>=(size_t __position)
;
bitset<_Nb>&
_Unchecked_set(size_t __pos)
;
bitset<_Nb>&
_Unchecked_set(size_t __pos, int __val)
;
bitset<_Nb>&
_Unchecked_reset(size_t __pos)
;
bitset<_Nb>&
_Unchecked_flip(size_t __pos)
;
bool
_Unchecked_test(size_t __pos) const
;
bitset<_Nb>&
set()
;
bitset<_Nb>&
set(size_t __position, bool __val = true)
;
bitset<_Nb>&
reset()
;
bitset<_Nb>&
reset(size_t __position)
;
bitset<_Nb>&
flip()
;
bitset<_Nb>&
flip(size_t __position)
{
this->_M_check(__position, ("bitset::flip"));
return _Unchecked_flip(__position);
}
bitset<_Nb>
operator~() const
{ return bitset<_Nb>(*this).flip(); }
reference
operator[](size_t __position)
{ return reference(*this, __position); }
bool
operator[](size_t __position) const
{ return _Unchecked_test(__position); }
unsigned long
to_ulong() const
{ return this->_M_do_to_ulong(); }
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
{ return this->_M_do_count(); }
size_t
size() const
{ return _Nb; }
bool
operator==(const bitset<_Nb>& __rhs) const
{ return this->_M_is_equal(__rhs); }
bool
operator!=(const bitset<_Nb>& __rhs) const
{ return !this->_M_is_equal(__rhs); }
bool
test(size_t __position) const
{
this->_M_check(__position, ("bitset::test"));
return _Unchecked_test(__position);
}
bool
all() const
{ return this->template _M_are_all<_Nb>(); }
bool
any() const
{ return this->_M_is_any(); }
bool
none() const
{ return !this->_M_is_any(); }
bitset<_Nb>
operator<<(size_t __position) const
{ return bitset<_Nb>(*this) <<= __position; }
bitset<_Nb>
operator>>(size_t __position) const
{ return bitset<_Nb>(*this) >>= __position; }
size_t
_Find_first() const
{ return this->_M_do_find_first(_Nb); }
size_t
_Find_next(size_t __prev) const
{ 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);
}
template<size_t _Nb>
inline bitset<_Nb>
operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
{
bitset<_Nb> __result(__x);
__result &= __y;
return __result;
}
template<size_t _Nb>
inline bitset<_Nb>
operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
{
bitset<_Nb> __result(__x);
__result |= __y;
return __result;
}
template <size_t _Nb>
inline bitset<_Nb>
operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
{
bitset<_Nb> __result(__x);
__result ^= __y;
return __result;
}
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;
}
}
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(), _M_finish(), _M_end_of_storage()
{ }
_Vector_impl(_Tp_alloc_type const& __a)
: _Tp_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
{ }
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()
{ return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
const _Tp_alloc_type&
_M_get_Tp_allocator() const
{ return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
allocator_type
get_allocator() const
{ 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()
{ _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)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
}
void
_M_deallocate(pointer __p, size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
if (__p)
_Tr::deallocate(_M_impl, __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;
}
};
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) { }
explicit
vector(size_type __n, const value_type& __value = value_type(),
const allocator_type& __a = allocator_type())
: _Base(__n, __a)
{ _M_fill_initialize(__n, __value); }
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());
}
template<typename _InputIterator>
vector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
_M_initialize_dispatch(__first, __last, _Integral());
}
~vector()
{ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator()); }
vector&
operator=(const vector& __x);
void
assign(size_type __n, const value_type& __val)
{ _M_fill_assign(__n, __val); }
template<typename _InputIterator>
void
assign(_InputIterator __first, _InputIterator __last)
{
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
_M_assign_dispatch(__first, __last, _Integral());
}
using _Base::get_allocator;
iterator
begin()
{ return iterator(this->_M_impl._M_start); }
const_iterator
begin() const
{ return const_iterator(this->_M_impl._M_start); }
iterator
end()
{ return iterator(this->_M_impl._M_finish); }
const_iterator
end() const
{ return const_iterator(this->_M_impl._M_finish); }
reverse_iterator
rbegin()
{ return reverse_iterator(end()); }
const_reverse_iterator
rbegin() const
{ return const_reverse_iterator(end()); }
reverse_iterator
rend()
{ return reverse_iterator(begin()); }
const_reverse_iterator
rend() const
{ return const_reverse_iterator(begin()); }
size_type
size() const
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
size_type
max_size() const
{ return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
void
resize(size_type __new_size, value_type __x = value_type())
{
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);
}
size_type
capacity() const
{ return size_type(this->_M_impl._M_end_of_storage
- this->_M_impl._M_start); }
bool
empty() const
{ return begin() == end(); }
void
reserve(size_type __n);
reference
operator[](size_type __n)
{ return *(this->_M_impl._M_start + __n); }
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_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)")
,
__n, this->size());
}
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];
}
reference
front()
{ return *begin(); }
const_reference
front() const
{ return *begin(); }
reference
back()
{ return *(end() - 1); }
const_reference
back() const
{ return *(end() - 1); }
pointer
data()
{ return _M_data_ptr(this->_M_impl._M_start); }
const_pointer
data() const
{ return _M_data_ptr(this->_M_impl._M_start); }
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_insert_aux(end(), __x);
}
void
pop_back()
{
--this->_M_impl._M_finish;
_Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
}
iterator
insert(iterator __position, const value_type& __x);
void
insert(iterator __position, size_type __n, const value_type& __x)
{ _M_fill_insert(__position, __n, __x); }
template<typename _InputIterator>
void
insert(iterator __position, _InputIterator __first,
_InputIterator __last)
{
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
_M_insert_dispatch(__position, __first, __last, _Integral());
}
iterator
erase(iterator __position)
{ return _M_erase(__position); }
iterator
erase(iterator __first, iterator __last)
{ return _M_erase(__first, __last); }
void
swap(vector& __x)
{
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()
{ _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;
}
}
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)
push_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)
{
this->_M_impl._M_finish =
std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
_M_get_Tp_allocator());
}
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);
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_insert_aux(iterator __position, const value_type& __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(pointer __pos)
{
std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
this->_M_impl._M_finish = __pos;
}
iterator
_M_erase(iterator __position);
iterator
_M_erase(iterator __first, iterator __last);
template<typename _Ptr>
_Ptr
_M_data_ptr(_Ptr __ptr) const
{ return __ptr; }
};
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())); }
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); }
}
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() : _M_p(0), _M_mask(0) { }
operator bool() const
{ return !!(*_M_p & _M_mask); }
_Bit_reference&
operator=(bool __x)
{
if (__x)
*_M_p |= _M_mask;
else
*_M_p &= ~_M_mask;
return *this;
}
_Bit_reference&
operator=(const _Bit_reference& __x)
{ 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()
{ *_M_p ^= _M_mask; }
};
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) { }
iterator
_M_const_cast() const
{ return *this; }
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) { }
_Bit_iterator
_M_const_cast() const
{ return _Bit_iterator(_M_p, _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 __gnu_cxx::__alloc_traits<_Alloc>::template
rebind<_Bit_type>::other _Bit_alloc_type;
typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type>
_Bit_alloc_traits;
typedef typename _Bit_alloc_traits::pointer _Bit_pointer;
struct _Bvector_impl
: public _Bit_alloc_type
{
_Bit_iterator _M_start;
_Bit_iterator _M_finish;
_Bit_pointer _M_end_of_storage;
_Bvector_impl()
: _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage()
{ }
_Bvector_impl(const _Bit_alloc_type& __a)
: _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
{ }
_Bit_type*
_M_end_addr() const
{
if (_M_end_of_storage)
return std::__addressof(_M_end_of_storage[-1]) + 1;
return 0;
}
};
public:
typedef _Alloc allocator_type;
_Bit_alloc_type&
_M_get_Bit_allocator()
{ return *static_cast<_Bit_alloc_type*>(&this->_M_impl); }
const _Bit_alloc_type&
_M_get_Bit_allocator() const
{ return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
allocator_type
get_allocator() const
{ return allocator_type(_M_get_Bit_allocator()); }
_Bvector_base()
: _M_impl() { }
_Bvector_base(const allocator_type& __a)
: _M_impl(__a) { }
~_Bvector_base()
{ this->_M_deallocate(); }
protected:
_Bvector_impl _M_impl;
_Bit_pointer
_M_allocate(size_t __n)
{ return _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); }
void
_M_deallocate()
{
if (_M_impl._M_start._M_p)
{
const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
_Bit_alloc_traits::deallocate(_M_impl,
_M_impl._M_end_of_storage - __n,
__n);
}
}
static size_t
_S_nword(size_t __n)
{ return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
{
typedef _Bvector_base<_Alloc> _Base;
typedef typename _Base::_Bit_pointer _Bit_pointer;
typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits;
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 bool& __value = bool(),
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_addr(),
__value ? ~0 : 0);
}
vector(const vector& __x)
: _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
{
_M_initialize(__x.size());
_M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
}
template<typename _InputIterator>
vector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
_M_initialize_dispatch(__first, __last, _Integral());
}
~vector() { }
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;
}
void
assign(size_type __n, const bool& __x)
{ _M_fill_assign(__n, __x); }
template<typename _InputIterator>
void
assign(_InputIterator __first, _InputIterator __last)
{
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
_M_assign_dispatch(__first, __last, _Integral());
}
iterator
begin()
{ return this->_M_impl._M_start; }
const_iterator
begin() const
{ return this->_M_impl._M_start; }
iterator
end()
{ return this->_M_impl._M_finish; }
const_iterator
end() const
{ return this->_M_impl._M_finish; }
reverse_iterator
rbegin()
{ return reverse_iterator(end()); }
const_reverse_iterator
rbegin() const
{ return const_reverse_iterator(end()); }
reverse_iterator
rend()
{ return reverse_iterator(begin()); }
const_reverse_iterator
rend() const
{ return const_reverse_iterator(begin()); }
size_type
size() const
{ return size_type(end() - begin()); }
size_type
max_size() const
{
const size_type __isize =
__gnu_cxx::__numeric_traits<difference_type>::__max
- int(_S_word_bit) + 1;
const size_type __asize
= _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
return (__asize <= __isize / int(_S_word_bit)
? __asize * int(_S_word_bit) : __isize);
}
size_type
capacity() const
{ return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
- begin()); }
bool
empty() const
{ 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_fmt(("vector<bool>::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)")
,
__n, this->size());
}
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() { }
void
push_back(bool __x)
{
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
*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);
_Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
__x._M_get_Bit_allocator());
}
static void
swap(reference __x, reference __y)
{
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_addr()
&& __position == end())
*this->_M_impl._M_finish++ = __x;
else
_M_insert_aux(__position._M_const_cast(), __x);
return begin() + __n;
}
template<typename _InputIterator>
void
insert(iterator __position,
_InputIterator __first, _InputIterator __last)
{
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
_M_insert_dispatch(__position, __first, __last, _Integral());
}
void
insert(iterator __position, size_type __n, const bool& __x)
{ _M_fill_insert(__position, __n, __x); }
void
pop_back()
{ --this->_M_impl._M_finish; }
iterator
erase(iterator __position)
{ return _M_erase(__position._M_const_cast()); }
iterator
erase(iterator __first, iterator __last)
{ return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
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
flip()
{
_Bit_type * const __end = this->_M_impl._M_end_addr();
for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
*__p = ~*__p;
}
void
clear()
{ _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_pointer __q = this->_M_allocate(__n);
this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
this->_M_impl._M_start = iterator(std::__addressof(*__q), 0);
this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
}
void
_M_reallocate(size_type __n);
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_addr(), __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_addr(), __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_addr(), __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; }
iterator
_M_erase(iterator __pos);
iterator
_M_erase(iterator __first, iterator __last);
};
}
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,
(this->_M_impl._M_start),
(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>
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
{
_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>::
_M_erase(iterator __position)
{
if (__position + 1 != end())
std::copy(__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>::
_M_erase(iterator __first, iterator __last)
{
if (__first != __last)
{
if (__last != end())
std::copy(__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)
{
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._M_impl._M_swap_data(this->_M_impl);
}
else if (__n > size())
{
std::fill(begin(), end(), __val);
this->_M_impl._M_finish =
std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
__n - size(), __val,
_M_get_Tp_allocator());
}
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>
void
vector<_Tp, _Alloc>::
_M_insert_aux(iterator __position, const _Tp& __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,
(*(this->_M_impl._M_finish - 1))
);
++this->_M_impl._M_finish;
_Tp __x_copy = __x;
std::copy_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1)
;
*__position = __x_copy;
}
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,
__x);
__new_finish = pointer();
__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>
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::copy_backward(__position.base(), __old_finish - __n, __old_finish)
;
std::fill(__position.base(), __position.base() + __n,
__x_copy);
}
else
{
this->_M_impl._M_finish =
std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
__n - __elems_after,
__x_copy,
_M_get_Tp_allocator());
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 = pointer();
__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>
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::copy_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_pointer __q = this->_M_allocate(__n);
iterator __start(std::__addressof(*__q), 0);
this->_M_impl._M_finish = _M_copy_aligned(begin(), end(), __start);
this->_M_deallocate();
this->_M_impl._M_start = __start;
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_pointer __q = this->_M_allocate(__len);
iterator __start(std::__addressof(*__q), 0);
iterator __i = _M_copy_aligned(begin(), __position, __start);
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 = __start;
}
}
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_pointer __q = this->_M_allocate(__len);
iterator __start(std::__addressof(*__q), 0);
iterator __i = _M_copy_aligned(begin(), __position, __start);
__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 = __start;
}
}
}
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_addr())
{
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_pointer __q = this->_M_allocate(__len);
iterator __start(std::__addressof(*__q), 0);
iterator __i = _M_copy_aligned(begin(), __position, __start);
*__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 = __start;
}
}
template<typename _Alloc>
typename vector<bool, _Alloc>::iterator
vector<bool, _Alloc>::
_M_erase(iterator __position)
{
if (__position + 1 != end())
std::copy(__position + 1, end(), __position);
--this->_M_impl._M_finish;
return __position;
}
template<typename _Alloc>
typename vector<bool, _Alloc>::iterator
vector<bool, _Alloc>::
_M_erase(iterator __first, iterator __last)
{
if (__first != __last)
_M_erase_at_end(std::copy(__last, end(), __first));
return __first;
}
}
namespace boost { namespace spirit {
namespace classic {
namespace utility { namespace impl {
template <typename CharT>
struct range {
range(CharT first, CharT last);
bool is_valid() const;
bool includes(CharT v) const;
bool includes(range const& r) const;
bool overlaps(range const& r) const;
void merge(range const& r);
CharT first;
CharT last;
};
template <typename CharT>
struct range_char_compare {
bool operator()(range<CharT> const& x, const CharT y) const
{ return x.first < y; }
bool operator()(const CharT x, range<CharT> const& y) const
{ return x < y.first; }
bool operator()(range<CharT> const& x, range<CharT> const& y) const
{ return x.first < y.first; }
};
template <typename CharT>
struct range_compare {
bool operator()(range<CharT> const& x, range<CharT> const& y) const
{ return x.first < y.first; }
};
template <typename CharT>
class range_run {
public:
typedef range<CharT> range_t;
typedef std::vector<range_t> run_t;
typedef typename run_t::iterator iterator;
typedef typename run_t::const_iterator const_iterator;
void swap(range_run& rr);
bool test(CharT v) const;
void set(range_t const& r);
void clear(range_t const& r);
void clear();
const_iterator begin() const;
const_iterator end() const;
private:
void merge(iterator iter, range_t const& r);
run_t run;
};
}}
}
}}
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
};
struct __numeric_limits_base
{
static const bool is_specialized = false;
static const int digits = 0;
static const int digits10 = 0;
static const bool is_signed = false;
static const bool is_integer = false;
static const bool is_exact = false;
static const int radix = 0;
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const float_denorm_style has_denorm = denorm_absent;
static const bool has_denorm_loss = false;
static const bool is_iec559 = false;
static const bool is_bounded = false;
static const bool is_modulo = false;
static const bool traps = false;
static const bool tinyness_before = false;
static const float_round_style round_style =
round_toward_zero;
};
template<typename _Tp>
struct numeric_limits : public __numeric_limits_base
{
static _Tp
min() throw() { return _Tp(); }
static _Tp
max() throw() { return _Tp(); }
static _Tp
epsilon() throw() { return _Tp(); }
static _Tp
round_error() throw() { return _Tp(); }
static _Tp
infinity() throw() { return _Tp(); }
static _Tp
quiet_NaN() throw() { return _Tp(); }
static _Tp
signaling_NaN() throw() ;
static _Tp
denorm_min() throw() ;
};
template<>
struct numeric_limits<bool>
{
static const bool is_specialized = true;
static bool
min() throw() ;
static bool
max() throw() ;
static const int digits = 1;
static const int digits10 = 0;
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
static const int radix = 2;
static bool
epsilon() throw() ;
static bool
round_error() throw() ;
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const float_denorm_style has_denorm
= denorm_absent;
static const bool has_denorm_loss = false;
static bool
infinity() throw() ;
static bool
quiet_NaN() throw() ;
static bool
signaling_NaN() throw() ;
static bool
denorm_min() throw() ;
static const bool is_iec559 = false;
static const bool is_bounded = true;
static const bool is_modulo = false;
static const bool traps = true;
static const bool tinyness_before = false;
static const float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<char>
{
static const bool is_specialized = true;
static char
min() throw() ;
static char
max() throw() ;
static const int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
static const int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
static const bool is_signed = ((char)(-1) < 0);
static const bool is_integer = true;
static const bool is_exact = true;
static const int radix = 2;
static char
epsilon() throw() ;
static char
round_error() throw() ;
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const float_denorm_style has_denorm
= denorm_absent;
static const bool has_denorm_loss = false;
static
char infinity() throw() ;
static char
quiet_NaN() throw() ;
static char
signaling_NaN() throw() ;
static char
denorm_min() throw() ;
static const bool is_iec559 = false;
static const bool is_bounded = true;
static const bool is_modulo = !is_signed;
static const bool traps = true;
static const bool tinyness_before = false;
static const float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<signed char>
{
static const bool is_specialized = true;
static signed char
min() throw() ;
static signed char
max() throw() ;
static const int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
static const int digits10
= ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);
static const bool is_signed = true;
static const bool is_integer = true;
static const bool is_exact = true;
static const int radix = 2;
static signed char
epsilon() throw() ;
static signed char
round_error() throw() ;
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const float_denorm_style has_denorm
= denorm_absent;
static const bool has_denorm_loss = false;
static signed char
infinity() throw() ;
static signed char
quiet_NaN() throw() ;
static signed char
signaling_NaN() throw()
;
static signed char
denorm_min() throw()
;
static const bool is_iec559 = false;
static const bool is_bounded = true;
static const bool is_modulo = false;
static const bool traps = true;
static const bool tinyness_before = false;
static const float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned char>
{
static const bool is_specialized = true;
static unsigned char
min() throw() ;
static unsigned char
max() throw() ;
static const int digits
= (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
static const int digits10
= ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
static const int radix = 2;
static unsigned char
epsilon() throw() ;
static unsigned char
round_error() throw() ;
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const float_denorm_style has_denorm
= denorm_absent;
static const bool has_denorm_loss = false;
static unsigned char
infinity() throw()
;
static unsigned char
quiet_NaN() throw()
;
static unsigned char
signaling_NaN() throw()
;
static unsigned char
denorm_min() throw()
;
static const bool is_iec559 = false;
static const bool is_bounded = true;
static const bool is_modulo = true;
static const bool traps = true;
static const bool tinyness_before = false;
static const float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<wchar_t>
{
static const bool is_specialized = true;
static wchar_t
min() throw() ;
static wchar_t
max() throw() ;
static const int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
static const int digits10
= ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);
static const bool is_signed = ((wchar_t)(-1) < 0);
static const bool is_integer = true;
static const bool is_exact = true;
static const int radix = 2;
static wchar_t
epsilon() throw() ;
static wchar_t
round_error() throw() ;
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const float_denorm_style has_denorm
= denorm_absent;
static const bool has_denorm_loss = false;
static wchar_t
infinity() throw() ;
static wchar_t
quiet_NaN() throw() ;
static wchar_t
signaling_NaN() throw() ;
static wchar_t
denorm_min() throw() ;
static const bool is_iec559 = false;
static const bool is_bounded = true;
static const bool is_modulo = !is_signed;
static const bool traps = true;
static const bool tinyness_before = false;
static const float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<short>
{
static const bool is_specialized = true;
static short
min() throw() ;
static short
max() throw() ;
static const int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
static const int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
static const bool is_signed = true;
static const bool is_integer = true;
static const bool is_exact = true;
static const int radix = 2;
static short
epsilon() throw() ;
static short
round_error() throw() ;
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const float_denorm_style has_denorm
= denorm_absent;
static const bool has_denorm_loss = false;
static short
infinity() throw() ;
static short
quiet_NaN() throw() ;
static short
signaling_NaN() throw() ;
static short
denorm_min() throw() ;
static const bool is_iec559 = false;
static const bool is_bounded = true;
static const bool is_modulo = false;
static const bool traps = true;
static const bool tinyness_before = false;
static const float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned short>
{
static const bool is_specialized = true;
static unsigned short
min() throw() ;
static unsigned short
max() throw() ;
static const int digits
= (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
static const int digits10
= ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
static const int radix = 2;
static unsigned short
epsilon() throw() ;
static unsigned short
round_error() throw() ;
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const float_denorm_style has_denorm
= denorm_absent;
static const bool has_denorm_loss = false;
static unsigned short
infinity() throw()
;
static unsigned short
quiet_NaN() throw()
;
static unsigned short
signaling_NaN() throw()
;
static unsigned short
denorm_min() throw()
;
static const bool is_iec559 = false;
static const bool is_bounded = true;
static const bool is_modulo = true;
static const bool traps = true;
static const bool tinyness_before = false;
static const float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<int>
{
static const bool is_specialized = true;
static int
min() throw() ;
static int
max() throw() ;
static const int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
static const int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
static const bool is_signed = true;
static const bool is_integer = true;
static const bool is_exact = true;
static const int radix = 2;
static int
epsilon() throw() ;
static int
round_error() throw() ;
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const float_denorm_style has_denorm
= denorm_absent;
static const bool has_denorm_loss = false;
static int
infinity() throw() ;
static int
quiet_NaN() throw() ;
static int
signaling_NaN() throw() ;
static int
denorm_min() throw() ;
static const bool is_iec559 = false;
static const bool is_bounded = true;
static const bool is_modulo = false;
static const bool traps = true;
static const bool tinyness_before = false;
static const float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned int>
{
static const bool is_specialized = true;
static unsigned int
min() throw() ;
static unsigned int
max() throw() ;
static const int digits
= (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
static const int digits10
= ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
static const int radix = 2;
static unsigned int
epsilon() throw() ;
static unsigned int
round_error() throw() ;
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const float_denorm_style has_denorm
= denorm_absent;
static const bool has_denorm_loss = false;
static unsigned int
infinity() throw() ;
static unsigned int
quiet_NaN() throw()
;
static unsigned int
signaling_NaN() throw()
;
static unsigned int
denorm_min() throw()
;
static const bool is_iec559 = false;
static const bool is_bounded = true;
static const bool is_modulo = true;
static const bool traps = true;
static const bool tinyness_before = false;
static const float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<long>
{
static const bool is_specialized = true;
static long
min() throw() ;
static long
max() throw() ;
static const int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
static const int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
static const bool is_signed = true;
static const bool is_integer = true;
static const bool is_exact = true;
static const int radix = 2;
static long
epsilon() throw() ;
static long
round_error() throw() ;
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const float_denorm_style has_denorm
= denorm_absent;
static const bool has_denorm_loss = false;
static long
infinity() throw() ;
static long
quiet_NaN() throw() ;
static long
signaling_NaN() throw() ;
static long
denorm_min() throw() ;
static const bool is_iec559 = false;
static const bool is_bounded = true;
static const bool is_modulo = false;
static const bool traps = true;
static const bool tinyness_before = false;
static const float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned long>
{
static const bool is_specialized = true;
static unsigned long
min() throw() ;
static unsigned long
max() throw() ;
static const int digits
= (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
static const int digits10
= ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
static const int radix = 2;
static unsigned long
epsilon() throw() ;
static unsigned long
round_error() throw() ;
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const float_denorm_style has_denorm
= denorm_absent;
static const bool has_denorm_loss = false;
static unsigned long
infinity() throw()
;
static unsigned long
quiet_NaN() throw()
;
static unsigned long
signaling_NaN() throw()
;
static unsigned long
denorm_min() throw()
;
static const bool is_iec559 = false;
static const bool is_bounded = true;
static const bool is_modulo = true;
static const bool traps = true;
static const bool tinyness_before = false;
static const float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<long long>
{
static const bool is_specialized = true;
static long long
min() throw() ;
static long long
max() throw() ;
static const int digits
= (sizeof(long long) * 8 - ((long long)(-1) < 0));
static const int digits10
= ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);
static const bool is_signed = true;
static const bool is_integer = true;
static const bool is_exact = true;
static const int radix = 2;
static long long
epsilon() throw() ;
static long long
round_error() throw() ;
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const float_denorm_style has_denorm
= denorm_absent;
static const bool has_denorm_loss = false;
static long long
infinity() throw() ;
static long long
quiet_NaN() throw() ;
static long long
signaling_NaN() throw()
;
static long long
denorm_min() throw() ;
static const bool is_iec559 = false;
static const bool is_bounded = true;
static const bool is_modulo = false;
static const bool traps = true;
static const bool tinyness_before = false;
static const float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned long long>
{
static const bool is_specialized = true;
static unsigned long long
min() throw() ;
static unsigned long long
max() throw() ;
static const int digits
= (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
static const int digits10
= ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
static const int radix = 2;
static unsigned long long
epsilon() throw() ;
static unsigned long long
round_error() throw() ;
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const float_denorm_style has_denorm
= denorm_absent;
static const bool has_denorm_loss = false;
static unsigned long long
infinity() throw()
;
static unsigned long long
quiet_NaN() throw()
;
static unsigned long long
signaling_NaN() throw()
;
static unsigned long long
denorm_min() throw()
;
static const bool is_iec559 = false;
static const bool is_bounded = true;
static const bool is_modulo = true;
static const bool traps = true;
static const bool tinyness_before = false;
static const float_round_style round_style
= round_toward_zero;
};
template<> struct numeric_limits<__int128> { static const bool is_specialized = true; static __int128 min() throw() ; static __int128 max() throw() ; static const int digits = 128 - 1; static const int digits10 = (128 - 1) * 643L / 2136; static const bool is_signed = true; static const bool is_integer = true; static const bool is_exact = true; static const int radix = 2; static __int128 epsilon() throw() ; static __int128 round_error() throw() ; static const int min_exponent = 0; static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; static const bool has_infinity = false; static const bool has_quiet_NaN = false; static const bool has_signaling_NaN = false; static const float_denorm_style has_denorm = denorm_absent; static const bool has_denorm_loss = false; static __int128 infinity() throw() ; static __int128 quiet_NaN() throw() ; static __int128 signaling_NaN() throw() ; static __int128 denorm_min() throw() ; static const bool is_iec559 = false; static const bool is_bounded = true; static const bool is_modulo = false; static const bool traps = true; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits<unsigned __int128> { static const bool is_specialized = true; static unsigned __int128 min() throw() ; static unsigned __int128 max() throw() ; static const int digits = 128; static const int digits10 = 128 * 643L / 2136; static const bool is_signed = false; static const bool is_integer = true; static const bool is_exact = true; static const int radix = 2; static unsigned __int128 epsilon() throw() ; static unsigned __int128 round_error() throw() ; static const int min_exponent = 0; static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; static const bool has_infinity = false; static const bool has_quiet_NaN = false; static const bool has_signaling_NaN = false; static const float_denorm_style has_denorm = denorm_absent; static const bool has_denorm_loss = false; static unsigned __int128 infinity() throw() ; static unsigned __int128 quiet_NaN() throw() ; static unsigned __int128 signaling_NaN() throw() ; static unsigned __int128 denorm_min() throw() ; static const bool is_iec559 = false; static const bool is_bounded = true; static const bool is_modulo = true; static const bool traps = true; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; };
template<>
struct numeric_limits<float>
{
static const bool is_specialized = true;
static float
min() throw() ;
static float
max() throw() ;
static const int digits = 24;
static const int digits10 = 6;
static const bool is_signed = true;
static const bool is_integer = false;
static const bool is_exact = false;
static const int radix = 2;
static float
epsilon() throw() ;
static float
round_error() throw() ;
static const int min_exponent = (-125);
static const int min_exponent10 = (-37);
static const int max_exponent = 128;
static const int max_exponent10 = 38;
static const bool has_infinity = 1;
static const bool has_quiet_NaN = 1;
static const bool has_signaling_NaN = has_quiet_NaN;
static const float_denorm_style has_denorm
= bool(1) ? denorm_present : denorm_absent;
static const bool has_denorm_loss
= false;
static float
infinity() throw() ;
static float
quiet_NaN() throw() ;
static float
signaling_NaN() throw() ;
static float
denorm_min() throw() ;
static const bool is_iec559
= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static const bool is_bounded = true;
static const bool is_modulo = false;
static const bool traps = false;
static const bool tinyness_before
= false;
static const float_round_style round_style
= round_to_nearest;
};
template<>
struct numeric_limits<double>
{
static const bool is_specialized = true;
static double
min() throw() ;
static double
max() throw() { return double(1.79769313486231570815e+308L); }
static const int digits = 53;
static const int digits10 = 15;
static const bool is_signed = true;
static const bool is_integer = false;
static const bool is_exact = false;
static const int radix = 2;
static double
epsilon() throw() { return double(2.22044604925031308085e-16L); }
static double
round_error() throw() { return 0.5; }
static const int min_exponent = (-1021);
static const int min_exponent10 = (-307);
static const int max_exponent = 1024;
static const int max_exponent10 = 308;
static const bool has_infinity = 1;
static const bool has_quiet_NaN = 1;
static const bool has_signaling_NaN = has_quiet_NaN;
static const float_denorm_style has_denorm
= bool(1) ? denorm_present : denorm_absent;
static const bool has_denorm_loss
= false;
static double
infinity() throw() { return __builtin_huge_val(); }
static double
quiet_NaN() throw() { return __builtin_nan(""); }
static double
signaling_NaN() throw() { return __builtin_nans(""); }
static double
denorm_min() throw() { return double(4.94065645841246544177e-324L); }
static const bool is_iec559
= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static const bool is_bounded = true;
static const bool is_modulo = false;
static const bool traps = false;
static const bool tinyness_before
= false;
static const float_round_style round_style
= round_to_nearest;
};
template<>
struct numeric_limits<long double>
{
static const bool is_specialized = true;
static long double
min() throw() { return 3.36210314311209350626e-4932L; }
static long double
max() throw() { return 1.18973149535723176502e+4932L; }
static const int digits = 64;
static const int digits10 = 18;
static const bool is_signed = true;
static const bool is_integer = false;
static const bool is_exact = false;
static const int radix = 2;
static long double
epsilon() throw() { return 1.08420217248550443401e-19L; }
static long double
round_error() throw() { return 0.5L; }
static const int min_exponent = (-16381);
static const int min_exponent10 = (-4931);
static const int max_exponent = 16384;
static const int max_exponent10 = 4932;
static const bool has_infinity = 1;
static const bool has_quiet_NaN = 1;
static const bool has_signaling_NaN = has_quiet_NaN;
static const float_denorm_style has_denorm
= bool(1) ? denorm_present : denorm_absent;
static const bool has_denorm_loss
= false;
static long double
infinity() throw() { return __builtin_huge_vall(); }
static long double
quiet_NaN() throw() { return __builtin_nanl(""); }
static long double
signaling_NaN() throw() { return __builtin_nansl(""); }
static long double
denorm_min() throw() { return 3.64519953188247460253e-4951L; }
static const bool is_iec559
= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static const bool is_bounded = true;
static const bool is_modulo = false;
static const bool traps = false;
static const bool tinyness_before =
false;
static const float_round_style round_style =
round_to_nearest;
};
}
namespace boost { namespace spirit {
namespace classic {
namespace utility { namespace impl {
template <typename CharT>
inline range<CharT>::range(CharT first_, CharT last_)
: first(first_), last(last_) {}
template <typename CharT>
inline bool
range<CharT>::is_valid() const
{ return first <= last; }
template <typename CharT>
inline bool
range<CharT>::includes(range const& r) const
{ return (first <= r.first) && (last >= r.last); }
template <typename CharT>
inline bool
range<CharT>::includes(CharT v) const
{ return (first <= v) && (last >= v); }
template <typename CharT>
inline bool
range<CharT>::overlaps(range const& r) const
{
CharT decr_first =
first == (std::numeric_limits<CharT>::min)() ? first : first-1;
CharT incr_last =
last == (std::numeric_limits<CharT>::max)() ? last : last+1;
return (decr_first <= r.last) && (incr_last >= r.first);
}
template <typename CharT>
inline void
range<CharT>::merge(range const& r)
{
first = (std::min)(first, r.first);
last = (std::max)(last, r.last);
}
template <typename CharT>
inline bool
range_run<CharT>::test(CharT v) const
{
if (!run.empty())
{
const_iterator iter =
std::lower_bound(
run.begin(), run.end(), v,
range_char_compare<CharT>()
);
if (iter != run.end() && iter->includes(v))
return true;
if (iter != run.begin())
return (--iter)->includes(v);
}
return false;
}
template <typename CharT>
inline void
range_run<CharT>::swap(range_run& rr)
{ run.swap(rr.run); }
template <typename CharT>
void
range_run<CharT>::merge(iterator iter, range<CharT> const& r)
{
iter->merge(r);
iterator i = iter + 1;
while (i != run.end() && iter->overlaps(*i))
iter->merge(*i++);
run.erase(iter+1, i);
}
template <typename CharT>
void
range_run<CharT>::set(range<CharT> const& r)
{
;
if (!run.empty())
{
iterator iter =
std::lower_bound(
run.begin(), run.end(), r,
range_compare<CharT>()
);
if ((iter != run.end() && iter->includes(r)) ||
((iter != run.begin()) && (iter - 1)->includes(r)))
return;
if (iter != run.begin() && (iter - 1)->overlaps(r))
merge(--iter, r);
else if (iter != run.end() && iter->overlaps(r))
merge(iter, r);
else
run.insert(iter, r);
}
else
{
run.push_back(r);
}
}
template <typename CharT>
void
range_run<CharT>::clear(range<CharT> const& r)
{
;
if (!run.empty())
{
iterator iter =
std::lower_bound(
run.begin(), run.end(), r,
range_compare<CharT>()
);
iterator left_iter;
if ((iter != run.begin()) &&
(left_iter = (iter - 1))->includes(r.first))
{
if (left_iter->last > r.last)
{
CharT save_last = left_iter->last;
left_iter->last = r.first-1;
run.insert(iter, range<CharT>(r.last+1, save_last));
return;
}
else
{
left_iter->last = r.first-1;
}
}
iterator i = iter;
while (i != run.end() && r.includes(*i))
i++;
if (i != run.end() && i->includes(r.last))
i->first = r.last+1;
run.erase(iter, i);
}
}
template <typename CharT>
inline void
range_run<CharT>::clear()
{ run.clear(); }
template <typename CharT>
inline typename range_run<CharT>::const_iterator
range_run<CharT>::begin() const
{ return run.begin(); }
template <typename CharT>
inline typename range_run<CharT>::const_iterator
range_run<CharT>::end() const
{ return run.end(); }
}}
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename CharT>
class basic_chset
{
public:
basic_chset();
basic_chset(basic_chset const& arg_);
bool test(CharT v) const;
void set(CharT from, CharT to);
void set(CharT c);
void clear(CharT from, CharT to);
void clear(CharT c);
void clear();
void inverse();
void swap(basic_chset& x);
basic_chset& operator|=(basic_chset const& x);
basic_chset& operator&=(basic_chset const& x);
basic_chset& operator-=(basic_chset const& x);
basic_chset& operator^=(basic_chset const& x);
private: utility::impl::range_run<CharT> rr;
};
template <typename CharT>
class basic_chset_8bit {
public:
basic_chset_8bit();
basic_chset_8bit(basic_chset_8bit const& arg_);
bool test(CharT v) const;
void set(CharT from, CharT to);
void set(CharT c);
void clear(CharT from, CharT to);
void clear(CharT c);
void clear();
void inverse();
void swap(basic_chset_8bit& x);
basic_chset_8bit& operator|=(basic_chset_8bit const& x);
basic_chset_8bit& operator&=(basic_chset_8bit const& x);
basic_chset_8bit& operator-=(basic_chset_8bit const& x);
basic_chset_8bit& operator^=(basic_chset_8bit const& x);
private: std::bitset<256> bset;
};
template <>
class basic_chset<char>
: public basic_chset_8bit<char> {};
template <>
class basic_chset<signed char>
: public basic_chset_8bit<signed char> {};
template <>
class basic_chset<unsigned char>
: public basic_chset_8bit<unsigned char> {};
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename CharT>
inline basic_chset<CharT>::basic_chset() {}
template <typename CharT>
inline basic_chset<CharT>::basic_chset(basic_chset const& arg_)
: rr(arg_.rr) {}
template <typename CharT>
inline bool
basic_chset<CharT>::test(CharT v) const
{ return rr.test(v); }
template <typename CharT>
inline void
basic_chset<CharT>::set(CharT from, CharT to)
{ rr.set(utility::impl::range<CharT>(from, to)); }
template <typename CharT>
inline void
basic_chset<CharT>::set(CharT c)
{ rr.set(utility::impl::range<CharT>(c, c)); }
template <typename CharT>
inline void
basic_chset<CharT>::clear(CharT from, CharT to)
{ rr.clear(utility::impl::range<CharT>(from, to)); }
template <typename CharT>
inline void
basic_chset<CharT>::clear()
{ rr.clear(); }
template <typename CharT>
inline void
basic_chset<CharT>::inverse()
{
basic_chset inv;
inv.set(
(std::numeric_limits<CharT>::min)(),
(std::numeric_limits<CharT>::max)()
);
inv -= *this;
swap(inv);
}
template <typename CharT>
inline void
basic_chset<CharT>::swap(basic_chset& x)
{ rr.swap(x.rr); }
template <typename CharT>
inline basic_chset<CharT>&
basic_chset<CharT>::operator|=(basic_chset<CharT> const& x)
{
typedef typename utility::impl::range_run<CharT>::const_iterator const_iterator;
for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter)
rr.set(*iter);
return *this;
}
template <typename CharT>
inline basic_chset<CharT>&
basic_chset<CharT>::operator&=(basic_chset<CharT> const& x)
{
basic_chset inv;
inv.set(
(std::numeric_limits<CharT>::min)(),
(std::numeric_limits<CharT>::max)()
);
inv -= x;
*this -= inv;
return *this;
}
template <typename CharT>
inline basic_chset<CharT>&
basic_chset<CharT>::operator-=(basic_chset<CharT> const& x)
{
typedef typename utility::impl::range_run<CharT>::const_iterator const_iterator;
for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter)
rr.clear(*iter);
return *this;
}
template <typename CharT>
inline basic_chset<CharT>&
basic_chset<CharT>::operator^=(basic_chset<CharT> const& x)
{
basic_chset bma = x;
bma -= *this;
*this -= x;
*this |= bma;
return *this;
}
template <typename CharT>
inline basic_chset_8bit<CharT>::basic_chset_8bit() {}
template <typename CharT>
inline basic_chset_8bit<CharT>::basic_chset_8bit(basic_chset_8bit const& arg_)
: bset(arg_.bset) {}
template <typename CharT>
inline bool
basic_chset_8bit<CharT>::test(CharT v) const
{ return bset.test((unsigned char)v); }
template <typename CharT>
inline void
basic_chset_8bit<CharT>::set(CharT from, CharT to)
{
for (int i = from; i <= to; ++i)
bset.set((unsigned char)i);
}
template <typename CharT>
inline void
basic_chset_8bit<CharT>::set(CharT c)
{ bset.set((unsigned char)c); }
template <typename CharT>
inline void
basic_chset_8bit<CharT>::clear(CharT from, CharT to)
{
for (int i = from; i <= to; ++i)
bset.reset((unsigned char)i);
}
template <typename CharT>
inline void
basic_chset_8bit<CharT>::clear(CharT c)
{ bset.reset((unsigned char)c); }
template <typename CharT>
inline void
basic_chset_8bit<CharT>::clear()
{ bset.reset(); }
template <typename CharT>
inline void
basic_chset_8bit<CharT>::inverse()
{ bset.flip(); }
template <typename CharT>
inline void
basic_chset_8bit<CharT>::swap(basic_chset_8bit& x)
{ std::swap(bset, x.bset); }
template <typename CharT>
inline basic_chset_8bit<CharT>&
basic_chset_8bit<CharT>::operator|=(basic_chset_8bit const& x)
{
bset |= x.bset;
return *this;
}
template <typename CharT>
inline basic_chset_8bit<CharT>&
basic_chset_8bit<CharT>::operator&=(basic_chset_8bit const& x)
{
bset &= x.bset;
return *this;
}
template <typename CharT>
inline basic_chset_8bit<CharT>&
basic_chset_8bit<CharT>::operator-=(basic_chset_8bit const& x)
{
bset &= ~x.bset;
return *this;
}
template <typename CharT>
inline basic_chset_8bit<CharT>&
basic_chset_8bit<CharT>::operator^=(basic_chset_8bit const& x)
{
bset ^= x.bset;
return *this;
}
}
}}
namespace boost { namespace spirit {
namespace classic {
namespace utility { namespace impl {
template <typename CharT, typename CharT2>
void construct_chset(boost::shared_ptr<basic_chset<CharT> >& ptr,
CharT2 const* definition);
}}
template <typename CharT = char>
class chset: public char_parser<chset<CharT> > {
public:
chset();
chset(chset const& arg_);
explicit chset(CharT arg_);
explicit chset(anychar_parser arg_);
explicit chset(nothing_parser arg_);
explicit chset(chlit<CharT> const& arg_);
explicit chset(range<CharT> const& arg_);
explicit chset(negated_char_parser<chlit<CharT> > const& arg_);
explicit chset(negated_char_parser<range<CharT> > const& arg_);
template <typename CharT2>
explicit chset(CharT2 const* definition)
: ptr(new basic_chset<CharT>())
{
utility::impl::construct_chset(ptr, definition);
}
~chset();
chset& operator=(chset const& rhs);
chset& operator=(CharT rhs);
chset& operator=(anychar_parser rhs);
chset& operator=(nothing_parser rhs);
chset& operator=(chlit<CharT> const& rhs);
chset& operator=(range<CharT> const& rhs);
chset& operator=(negated_char_parser<chlit<CharT> > const& rhs);
chset& operator=(negated_char_parser<range<CharT> > const& rhs);
void set(range<CharT> const& arg_);
void set(negated_char_parser<chlit<CharT> > const& arg_);
void set(negated_char_parser<range<CharT> > const& arg_);
void clear(range<CharT> const& arg_);
void clear(negated_char_parser<range<CharT> > const& arg_);
bool test(CharT ch) const;
chset& inverse();
void swap(chset& x);
chset& operator|=(chset const& x);
chset& operator&=(chset const& x);
chset& operator-=(chset const& x);
chset& operator^=(chset const& x);
private:
boost::shared_ptr<basic_chset<CharT> > ptr;
};
template <typename CharT>
inline chset<CharT>
chset_p(chlit<CharT> const& arg_)
{ return chset<CharT>(arg_); }
template <typename CharT>
inline chset<CharT>
chset_p(range<CharT> const& arg_)
{ return chset<CharT>(arg_); }
template <typename CharT>
inline chset<CharT>
chset_p(negated_char_parser<chlit<CharT> > const& arg_)
{ return chset<CharT>(arg_); }
template <typename CharT>
inline chset<CharT>
chset_p(negated_char_parser<range<CharT> > const& arg_)
{ return chset<CharT>(arg_); }
inline chset<char>
chset_p(char const* init)
{ return chset<char>(init); }
inline chset<wchar_t>
chset_p(wchar_t const* init)
{ return chset<wchar_t>(init); }
inline chset<char>
chset_p(char ch)
{ return chset<char>(ch); }
inline chset<wchar_t>
chset_p(wchar_t ch)
{ return chset<wchar_t>(ch); }
inline chset<int>
chset_p(int ch)
{ return chset<int>(ch); }
inline chset<unsigned int>
chset_p(unsigned int ch)
{ return chset<unsigned int>(ch); }
inline chset<short>
chset_p(short ch)
{ return chset<short>(ch); }
inline chset<unsigned short>
chset_p(unsigned short ch)
{ return chset<unsigned short>(ch); }
inline chset<long>
chset_p(long ch)
{ return chset<long>(ch); }
inline chset<unsigned long>
chset_p(unsigned long ch)
{ return chset<unsigned long>(ch); }
inline chset< ::boost::long_long_type>
chset_p( ::boost::long_long_type ch)
{ return chset< ::boost::long_long_type>(ch); }
inline chset< ::boost::ulong_long_type>
chset_p( ::boost::ulong_long_type ch)
{ return chset< ::boost::ulong_long_type>(ch); }
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const& a, chset<CharT> const& b)
{
return chset<CharT>(a) |= b;
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const& a, chset<CharT> const& b)
{
return chset<CharT>(a) -= b;
}
template <typename CharT>
inline chset<CharT>
operator~(chset<CharT> const& a)
{
return chset<CharT>(a).inverse();
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& a, chset<CharT> const& b)
{
return chset<CharT>(a) &= b;
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, chset<CharT> const& b)
{
return chset<CharT>(a) ^= b;
}
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const& a, range<CharT> const& b)
{
chset<CharT> a_(a);
a_.set(b);
return a_;
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& a, range<CharT> const& b)
{
chset<CharT> a_(a);
if(b.first != (std::numeric_limits<CharT>::min)()) {
a_.clear(range<CharT>((std::numeric_limits<CharT>::min)(), b.first - 1));
}
if(b.last != (std::numeric_limits<CharT>::max)()) {
a_.clear(range<CharT>(b.last + 1, (std::numeric_limits<CharT>::max)()));
}
return a_;
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const& a, range<CharT> const& b)
{
chset<CharT> a_(a);
a_.clear(b);
return a_;
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, range<CharT> const& b)
{
return a ^ chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator|(range<CharT> const& a, chset<CharT> const& b)
{
chset<CharT> b_(b);
b_.set(a);
return b_;
}
template <typename CharT>
inline chset<CharT>
operator&(range<CharT> const& a, chset<CharT> const& b)
{
chset<CharT> b_(b);
if(a.first != (std::numeric_limits<CharT>::min)()) {
b_.clear(range<CharT>((std::numeric_limits<CharT>::min)(), a.first - 1));
}
if(a.last != (std::numeric_limits<CharT>::max)()) {
b_.clear(range<CharT>(a.last + 1, (std::numeric_limits<CharT>::max)()));
}
return b_;
}
template <typename CharT>
inline chset<CharT>
operator-(range<CharT> const& a, chset<CharT> const& b)
{
return chset<CharT>(a) - b;
}
template <typename CharT>
inline chset<CharT>
operator^(range<CharT> const& a, chset<CharT> const& b)
{
return chset<CharT>(a) ^ b;
}
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const& a, CharT b)
{
return a | chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& a, CharT b)
{
return a & chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const& a, CharT b)
{
return a - chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, CharT b)
{
return a ^ chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator|(CharT a, chset<CharT> const& b)
{
return chset<CharT>(a) | b;
}
template <typename CharT>
inline chset<CharT>
operator&(CharT a, chset<CharT> const& b)
{
return chset<CharT>(a) & b;
}
template <typename CharT>
inline chset<CharT>
operator-(CharT a, chset<CharT> const& b)
{
return chset<CharT>(a) - b;
}
template <typename CharT>
inline chset<CharT>
operator^(CharT a, chset<CharT> const& b)
{
return chset<CharT>(a) ^ b;
}
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const& a, chlit<CharT> const& b)
{
return a | chset<CharT>(b.ch);
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& a, chlit<CharT> const& b)
{
return a & chset<CharT>(b.ch);
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const& a, chlit<CharT> const& b)
{
return a - chset<CharT>(b.ch);
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, chlit<CharT> const& b)
{
return a ^ chset<CharT>(b.ch);
}
template <typename CharT>
inline chset<CharT>
operator|(chlit<CharT> const& a, chset<CharT> const& b)
{
return chset<CharT>(a.ch) | b;
}
template <typename CharT>
inline chset<CharT>
operator&(chlit<CharT> const& a, chset<CharT> const& b)
{
return chset<CharT>(a.ch) & b;
}
template <typename CharT>
inline chset<CharT>
operator-(chlit<CharT> const& a, chset<CharT> const& b)
{
return chset<CharT>(a.ch) - b;
}
template <typename CharT>
inline chset<CharT>
operator^(chlit<CharT> const& a, chset<CharT> const& b)
{
return chset<CharT>(a.ch) ^ b;
}
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
{
return a | chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
{
return a & chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
{
return a - chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
{
return a ^ chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator|(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
{
return chset<CharT>(a) | b;
}
template <typename CharT>
inline chset<CharT>
operator&(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
{
return chset<CharT>(a) & b;
}
template <typename CharT>
inline chset<CharT>
operator-(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
{
return chset<CharT>(a) - b;
}
template <typename CharT>
inline chset<CharT>
operator^(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
{
return chset<CharT>(a) ^ b;
}
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
{
return a | chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
{
return a & chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
{
return a - chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
{
return a ^ chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator|(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
{
return chset<CharT>(a) | b;
}
template <typename CharT>
inline chset<CharT>
operator&(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
{
return chset<CharT>(a) & b;
}
template <typename CharT>
inline chset<CharT>
operator-(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
{
return chset<CharT>(a) - b;
}
template <typename CharT>
inline chset<CharT>
operator^(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
{
return chset<CharT>(a) ^ b;
}
namespace impl {
template <typename CharT>
inline boost::spirit::classic::range<CharT> const&
full()
{
static boost::spirit::classic::range<CharT> full_(
(std::numeric_limits<CharT>::min)(),
(std::numeric_limits<CharT>::max)());
return full_;
}
template <typename CharT>
inline boost::spirit::classic::range<CharT> const&
empty()
{
static boost::spirit::classic::range<CharT> empty_;
return empty_;
}
}
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const&, anychar_parser)
{
return chset<CharT>(impl::full<CharT>());
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& a, anychar_parser)
{
return a;
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const&, anychar_parser)
{
return chset<CharT>();
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, anychar_parser)
{
return ~a;
}
template <typename CharT>
inline chset<CharT>
operator|(anychar_parser, chset<CharT> const& )
{
return chset<CharT>(impl::full<CharT>());
}
template <typename CharT>
inline chset<CharT>
operator&(anychar_parser, chset<CharT> const& b)
{
return b;
}
template <typename CharT>
inline chset<CharT>
operator-(anychar_parser, chset<CharT> const& b)
{
return ~b;
}
template <typename CharT>
inline chset<CharT>
operator^(anychar_parser, chset<CharT> const& b)
{
return ~b;
}
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const& a, nothing_parser)
{
return a;
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& , nothing_parser)
{
return impl::empty<CharT>();
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const& a, nothing_parser)
{
return a;
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, nothing_parser)
{
return a;
}
template <typename CharT>
inline chset<CharT>
operator|(nothing_parser, chset<CharT> const& b)
{
return b;
}
template <typename CharT>
inline chset<CharT>
operator&(nothing_parser, chset<CharT> const& )
{
return impl::empty<CharT>();
}
template <typename CharT>
inline chset<CharT>
operator-(nothing_parser, chset<CharT> const& )
{
return impl::empty<CharT>();
}
template <typename CharT>
inline chset<CharT>
operator^(nothing_parser, chset<CharT> const& b)
{
return b;
}
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename CharT>
chset<CharT>
operator~(chset<CharT> const& a);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, range<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, range<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, range<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, range<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(range<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(range<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(range<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(range<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, chlit<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, chlit<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, chlit<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, chlit<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chlit<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(chlit<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(chlit<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(chlit<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator|(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator|(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, CharT b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, CharT b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, CharT b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, CharT b);
template <typename CharT>
chset<CharT>
operator|(CharT a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(CharT a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(CharT a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(CharT a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, anychar_parser b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, anychar_parser b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, anychar_parser b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, anychar_parser b);
template <typename CharT>
chset<CharT>
operator|(anychar_parser a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(anychar_parser a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(anychar_parser a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(anychar_parser a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, nothing_parser b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, nothing_parser b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, nothing_parser b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, nothing_parser b);
template <typename CharT>
chset<CharT>
operator|(nothing_parser a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(nothing_parser a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(nothing_parser a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(nothing_parser a, chset<CharT> const& b);
}
}}
namespace boost { namespace spirit {
namespace classic {
namespace utility { namespace impl {
template <typename CharT>
inline void
detach(boost::shared_ptr<basic_chset<CharT> >& ptr)
{
if (!ptr.unique())
ptr = boost::shared_ptr<basic_chset<CharT> >
(new basic_chset<CharT>(*ptr));
}
template <typename CharT>
inline void
detach_clear(boost::shared_ptr<basic_chset<CharT> >& ptr)
{
if (ptr.unique())
ptr->clear();
else
ptr.reset(new basic_chset<CharT>());
}
template <typename CharT, typename CharT2>
void construct_chset(boost::shared_ptr<basic_chset<CharT> >& ptr,
CharT2 const* definition)
{
CharT2 ch = *definition++;
while (ch)
{
CharT2 next = *definition++;
if (next == '-')
{
next = *definition++;
if (next == 0)
{
ptr->set(ch);
ptr->set('-');
break;
}
ptr->set(ch, next);
}
else
{
ptr->set(ch);
}
ch = next;
}
}
}}
template <typename CharT>
inline chset<CharT>::chset()
: ptr(new basic_chset<CharT>()) {}
template <typename CharT>
inline chset<CharT>::chset(chset const& arg_)
: ptr(new basic_chset<CharT>(*arg_.ptr)) {}
template <typename CharT>
inline chset<CharT>::chset(CharT arg_)
: ptr(new basic_chset<CharT>())
{ ptr->set(arg_); }
template <typename CharT>
inline chset<CharT>::chset(anychar_parser )
: ptr(new basic_chset<CharT>())
{
ptr->set(
(std::numeric_limits<CharT>::min)(),
(std::numeric_limits<CharT>::max)()
);
}
template <typename CharT>
inline chset<CharT>::chset(nothing_parser arg_)
: ptr(new basic_chset<CharT>()) {}
template <typename CharT>
inline chset<CharT>::chset(chlit<CharT> const& arg_)
: ptr(new basic_chset<CharT>())
{ ptr->set(arg_.ch); }
template <typename CharT>
inline chset<CharT>::chset(range<CharT> const& arg_)
: ptr(new basic_chset<CharT>())
{ ptr->set(arg_.first, arg_.last); }
template <typename CharT>
inline chset<CharT>::chset(negated_char_parser<chlit<CharT> > const& arg_)
: ptr(new basic_chset<CharT>())
{
set(arg_);
}
template <typename CharT>
inline chset<CharT>::chset(negated_char_parser<range<CharT> > const& arg_)
: ptr(new basic_chset<CharT>())
{
set(arg_);
}
template <typename CharT>
inline chset<CharT>::~chset() {}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(chset const& rhs)
{
ptr = rhs.ptr;
return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(CharT rhs)
{
utility::impl::detach_clear(ptr);
ptr->set(rhs);
return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(anychar_parser rhs)
{
utility::impl::detach_clear(ptr);
ptr->set(
(std::numeric_limits<CharT>::min)(),
(std::numeric_limits<CharT>::max)()
);
return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(nothing_parser rhs)
{
utility::impl::detach_clear(ptr);
return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(chlit<CharT> const& rhs)
{
utility::impl::detach_clear(ptr);
ptr->set(rhs.ch);
return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(range<CharT> const& rhs)
{
utility::impl::detach_clear(ptr);
ptr->set(rhs.first, rhs.last);
return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(negated_char_parser<chlit<CharT> > const& rhs)
{
utility::impl::detach_clear(ptr);
set(rhs);
return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(negated_char_parser<range<CharT> > const& rhs)
{
utility::impl::detach_clear(ptr);
set(rhs);
return *this;
}
template <typename CharT>
inline void
chset<CharT>::set(range<CharT> const& arg_)
{
utility::impl::detach(ptr);
ptr->set(arg_.first, arg_.last);
}
template <typename CharT>
inline void
chset<CharT>::set(negated_char_parser<chlit<CharT> > const& arg_)
{
utility::impl::detach(ptr);
if(arg_.positive.ch != (std::numeric_limits<CharT>::min)()) {
ptr->set((std::numeric_limits<CharT>::min)(), arg_.positive.ch - 1);
}
if(arg_.positive.ch != (std::numeric_limits<CharT>::max)()) {
ptr->set(arg_.positive.ch + 1, (std::numeric_limits<CharT>::max)());
}
}
template <typename CharT>
inline void
chset<CharT>::set(negated_char_parser<range<CharT> > const& arg_)
{
utility::impl::detach(ptr);
if(arg_.positive.first != (std::numeric_limits<CharT>::min)()) {
ptr->set((std::numeric_limits<CharT>::min)(), arg_.positive.first - 1);
}
if(arg_.positive.last != (std::numeric_limits<CharT>::max)()) {
ptr->set(arg_.positive.last + 1, (std::numeric_limits<CharT>::max)());
}
}
template <typename CharT>
inline void
chset<CharT>::clear(range<CharT> const& arg_)
{
utility::impl::detach(ptr);
ptr->clear(arg_.first, arg_.last);
}
template <typename CharT>
inline void
chset<CharT>::clear(negated_char_parser<range<CharT> > const& arg_)
{
utility::impl::detach(ptr);
if(arg_.positive.first != (std::numeric_limits<CharT>::min)()) {
ptr->clear((std::numeric_limits<CharT>::min)(), arg_.positive.first - 1);
}
if(arg_.positive.last != (std::numeric_limits<CharT>::max)()) {
ptr->clear(arg_.positive.last + 1, (std::numeric_limits<CharT>::max)());
}
}
template <typename CharT>
inline bool
chset<CharT>::test(CharT ch) const
{ return ptr->test(ch); }
template <typename CharT>
inline chset<CharT>&
chset<CharT>::inverse()
{
utility::impl::detach(ptr);
ptr->inverse();
return *this;
}
template <typename CharT>
inline void
chset<CharT>::swap(chset& x)
{ ptr.swap(x.ptr); }
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator|=(chset const& x)
{
utility::impl::detach(ptr);
*ptr |= *x.ptr;
return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator&=(chset const& x)
{
utility::impl::detach(ptr);
*ptr &= *x.ptr;
return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator-=(chset const& x)
{
utility::impl::detach(ptr);
*ptr -= *x.ptr;
return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator^=(chset const& x)
{
utility::impl::detach(ptr);
*ptr ^= *x.ptr;
return *this;
}
}
}}
extern "C" {
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)));
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)));
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)));
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 ();
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
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)));
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void *
__attribute__ ((__leaf__)) memcpy (void *__restrict __dest, const void *__restrict __src, size_t __len) throw ()
{
return __builtin___memcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void *
__attribute__ ((__leaf__)) memmove (void *__dest, const void *__src, size_t __len) throw ()
{
return __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void *
__attribute__ ((__leaf__)) mempcpy (void *__restrict __dest, const void *__restrict __src, size_t __len) throw ()
{
return __builtin___mempcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void *
__attribute__ ((__leaf__)) memset (void *__dest, int __ch, size_t __len) throw ()
{
return __builtin___memset_chk (__dest, __ch, __len, __builtin_object_size (__dest, 0));
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void
__attribute__ ((__leaf__)) bcopy (const void *__src, void *__dest, size_t __len) throw ()
{
(void) __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void
__attribute__ ((__leaf__)) bzero (void *__dest, size_t __len) throw ()
{
(void) __builtin___memset_chk (__dest, '\0', __len, __builtin_object_size (__dest, 0));
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__leaf__)) strcpy (char *__restrict __dest, const char *__restrict __src) throw ()
{
return __builtin___strcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__leaf__)) stpcpy (char *__restrict __dest, const char *__restrict __src) throw ()
{
return __builtin___stpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__leaf__)) strncpy (char *__restrict __dest, const char *__restrict __src, size_t __len) throw ()
{
return __builtin___strncpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
}
extern char *__stpncpy_chk (char *__dest, const char *__src, size_t __n,
size_t __destlen) throw ();
extern char *__stpncpy_alias (char *__dest, const char *__src, size_t __n) throw () __asm__ ("" "stpncpy")
;
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__leaf__)) stpncpy (char *__dest, const char *__src, size_t __n) throw ()
{
if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1
&& (!__builtin_constant_p (__n) || __n > __builtin_object_size (__dest, 2 > 1)))
return __stpncpy_chk (__dest, __src, __n, __builtin_object_size (__dest, 2 > 1));
return __stpncpy_alias (__dest, __src, __n);
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__leaf__)) strcat (char *__restrict __dest, const char *__restrict __src) throw ()
{
return __builtin___strcat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__leaf__)) strncat (char *__restrict __dest, const char *__restrict __src, size_t __len) throw ()
{
return __builtin___strncat_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) void *
__mempcpy_inline (void *__restrict __dest,
const void *__restrict __src, size_t __n)
{
return (char *) memcpy (__dest, __src, __n) + __n;
}
}
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;
}
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long int uint64_t;
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;
typedef signed char int_fast8_t;
typedef long int int_fast16_t;
typedef long int int_fast32_t;
typedef long int int_fast64_t;
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;
typedef unsigned long int uintptr_t;
typedef long int intmax_t;
typedef unsigned long int uintmax_t;
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;
}
namespace boost {
using ::intptr_t;
using ::uintptr_t;
}
namespace boost {
namespace noncopyable_
{
class noncopyable
{
protected:
noncopyable() {}
~noncopyable() {}
private:
noncopyable( const noncopyable& );
noncopyable& operator=( const noncopyable& );
};
}
typedef noncopyable_::noncopyable noncopyable;
}
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, (-0x7f - 1), 0x7f>
{ };
template<>
class integer_traits<signed char>
: public std::numeric_limits<signed char>,
public detail::integer_traits_base<signed char, (-0x7f - 1), 0x7f>
{ };
template<>
class integer_traits<unsigned char>
: public std::numeric_limits<unsigned char>,
public detail::integer_traits_base<unsigned char, 0, (0x7f * 2 + 1)>
{ };
template<>
class integer_traits<wchar_t>
: public std::numeric_limits<wchar_t>,
public detail::integer_traits_base<wchar_t, (-0x7fffffff - 1), 0x7fffffff>
{ };
template<>
class integer_traits<short>
: public std::numeric_limits<short>,
public detail::integer_traits_base<short, (-0x7fff - 1), 0x7fff>
{ };
template<>
class integer_traits<unsigned short>
: public std::numeric_limits<unsigned short>,
public detail::integer_traits_base<unsigned short, 0, (0x7fff * 2 + 1)>
{ };
template<>
class integer_traits<int>
: public std::numeric_limits<int>,
public detail::integer_traits_base<int, (-0x7fffffff - 1), 0x7fffffff>
{ };
template<>
class integer_traits<unsigned int>
: public std::numeric_limits<unsigned int>,
public detail::integer_traits_base<unsigned int, 0, (0x7fffffff * 2U + 1U)>
{ };
template<>
class integer_traits<long>
: public std::numeric_limits<long>,
public detail::integer_traits_base<long, (-0x7fffffffffffffffL - 1L), 0x7fffffffffffffffL>
{ };
template<>
class integer_traits<unsigned long>
: public std::numeric_limits<unsigned long>,
public detail::integer_traits_base<unsigned long, 0, (0x7fffffffffffffffL * 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, (-0x7fffffffffffffffLL -1), 0x7fffffffffffffffLL>
{ };
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, (0x7fffffffffffffffLL * 2ULL + 1)>
{ };
}
namespace boost {
namespace archive {
class library_version_type {
private:
typedef uint_least16_t base_type;
base_type t;
public:
library_version_type(): t(0) {};
explicit library_version_type(const unsigned int & t_) : t(t_){
(static_cast<void> (0))
;
}
library_version_type(const library_version_type & t_) :
t(t_.t)
{}
library_version_type & operator=(const library_version_type & rhs){
t = rhs.t;
return *this;
}
operator base_type () const {
return t;
}
operator base_type & (){
return t;
}
bool operator==(const library_version_type & rhs) const {
return t == rhs.t;
}
bool operator<(const library_version_type & rhs) const {
return t < rhs.t;
}
};
library_version_type
BOOST_ARCHIVE_VERSION();
class version_type {
private:
typedef uint_least32_t base_type;
base_type t;
public:
version_type(): t(0) {};
explicit version_type(const unsigned int & t_) : t(t_){
(static_cast<void> (0))
;
}
version_type(const version_type & t_) :
t(t_.t)
{}
version_type & operator=(const version_type & rhs){
t = rhs.t;
return *this;
}
operator base_type () const {
return t;
}
operator base_type & (){
return t;
}
bool operator==(const version_type & rhs) const {
return t == rhs.t;
}
bool operator<(const version_type & rhs) const {
return t < rhs.t;
}
};
class class_id_type {
private:
typedef int_least16_t base_type;
base_type t;
public:
class_id_type() : t(0) {};
explicit class_id_type(const int t_) : t(t_){
(static_cast<void> (0))
;
}
explicit class_id_type(const std::size_t t_) : t(t_){
}
class_id_type(const class_id_type & t_) :
t(t_.t)
{}
class_id_type & operator=(const class_id_type & rhs){
t = rhs.t;
return *this;
}
operator int () const {
return t;
}
operator int_least16_t &() {
return t;
}
bool operator==(const class_id_type & rhs) const {
return t == rhs.t;
}
bool operator<(const class_id_type & rhs) const {
return t < rhs.t;
}
};
class object_id_type {
private:
typedef uint_least32_t base_type;
base_type t;
public:
object_id_type(): t(0) {};
explicit object_id_type(const std::size_t & t_) : t(t_){
(static_cast<void> (0))
;
}
object_id_type(const object_id_type & t_) :
t(t_.t)
{}
object_id_type & operator=(const object_id_type & rhs){
t = rhs.t;
return *this;
}
operator uint_least32_t () const {
return t;
}
operator uint_least32_t & () {
return t;
}
bool operator==(const object_id_type & rhs) const {
return t == rhs.t;
}
bool operator<(const object_id_type & rhs) const {
return t < rhs.t;
}
};
struct tracking_type {
bool t;
explicit tracking_type(const bool t_ = false)
: t(t_)
{};
tracking_type(const tracking_type & t_)
: t(t_.t)
{}
operator bool () const {
return t;
};
operator bool & () {
return t;
};
tracking_type & operator=(const bool t_){
t = t_;
return *this;
}
bool operator==(const tracking_type & rhs) const {
return t == rhs.t;
}
bool operator==(const bool & rhs) const {
return t == rhs;
}
tracking_type & operator=(const tracking_type & rhs){
t = rhs.t;
return *this;
}
};
struct class_name_type :
private boost::noncopyable
{
char *t;
operator const char * & () const {
return const_cast<const char * &>(t);
}
operator char * () {
return t;
}
std::size_t size() const {
return std::strlen(t);
}
explicit class_name_type(const char *key_)
: t(const_cast<char *>(key_)){}
explicit class_name_type(char *key_)
: t(key_){}
class_name_type & operator=(const class_name_type & rhs){
t = rhs.t;
return *this;
}
};
enum archive_flags {
no_header = 1,
no_codecvt = 2,
no_xml_tag_checking = 4,
no_tracking = 8,
flags_last = 8
};
const char *
BOOST_ARCHIVE_SIGNATURE();
class class_id_reference_type : public class_id_type { public: explicit class_id_reference_type(const class_id_type tt) : class_id_type(tt){} };
class class_id_optional_type : public class_id_type { public: explicit class_id_optional_type(const class_id_type tt) : class_id_type(tt){} };
class object_reference_type : public object_id_type { public: explicit object_reference_type(const object_id_type tt) : object_id_type(tt){} };
}
}
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: };
}
namespace boost {
namespace serialization {
enum level_type
{
not_serializable = 0,
primitive_type = 1,
object_serializable = 2,
object_class_info = 3
};
}
}
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;
}
}
}
namespace boost { namespace serialization { template <> struct implementation_level_impl< const boost::archive::library_version_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 implementation_level_impl< const boost::archive::version_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 implementation_level_impl< const boost::archive::class_id_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 implementation_level_impl< const boost::archive::class_id_reference_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 implementation_level_impl< const boost::archive::class_id_optional_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 implementation_level_impl< const boost::archive::class_name_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 implementation_level_impl< const boost::archive::object_id_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 implementation_level_impl< const boost::archive::object_reference_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 implementation_level_impl< const boost::archive::tracking_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<class T>
struct is_bitwise_serializable
: public is_arithmetic< T >
{};
}
}
namespace boost { namespace serialization { template<> struct is_bitwise_serializable< boost::archive::library_version_type > : mpl::true_ {}; }}
namespace boost { namespace serialization { template<> struct is_bitwise_serializable< boost::archive::version_type > : mpl::true_ {}; }}
namespace boost { namespace serialization { template<> struct is_bitwise_serializable< boost::archive::class_id_type > : mpl::true_ {}; }}
namespace boost { namespace serialization { template<> struct is_bitwise_serializable< boost::archive::class_id_reference_type > : mpl::true_ {}; }}
namespace boost { namespace serialization { template<> struct is_bitwise_serializable< boost::archive::class_id_optional_type > : mpl::true_ {}; }}
namespace boost { namespace serialization { template<> struct is_bitwise_serializable< boost::archive::class_name_type > : mpl::true_ {}; }}
namespace boost { namespace serialization { template<> struct is_bitwise_serializable< boost::archive::object_id_type > : mpl::true_ {}; }}
namespace boost { namespace serialization { template<> struct is_bitwise_serializable< boost::archive::object_reference_type > : mpl::true_ {}; }}
namespace boost { namespace serialization { template<> struct is_bitwise_serializable< boost::archive::tracking_type > : mpl::true_ {}; }}
namespace boost { namespace mpl {
template< typename SourceTag, typename TargetTag > struct numeric_cast
{
template< typename N > struct apply;
};
}}
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;
};
}}}
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];
};
}}}
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<U> 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; };
}}}
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 >
{
};
}}
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<U> 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; };
}}}
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
{
};
}}
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
>
{
};
};
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
>
{
};
};
}}}
namespace boost { namespace mpl { namespace aux {
}}}
namespace boost { namespace mpl { namespace aux {
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 };
};
}}}
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 ) >
{
};
};
}}
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 ) >
{
};
};
}}
namespace boost {
namespace serialization {
enum tracking_type
{
track_never = 0,
track_selectively = 1,
track_always = 2
};
}
}
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 {
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
Version == 0 || Level >= object_class_info
) == 0 ? false : true) >)> boost_static_assert_typedef_53 __attribute__((unused))
;
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
Tracking == track_never || Level >= object_serializable
) == 0 ? false : true) >)> boost_static_assert_typedef_54 __attribute__((unused))
;
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;
};
}
}
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;
};
}
}
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;
}
}
}
namespace mpl_ {
struct failed {};
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 };
};
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 {};
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<p>::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 );
}
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;
}
}
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 ) >
{
};
};
}}
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 ) >
{
};
};
}}
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 ) >
{
};
};
}}
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 ) >
{
};
};
}}
namespace boost {
namespace archive {
template<class CharType>
class basic_xml_grammar {
public:
struct return_values;
friend struct return_values;
private:
typedef
typename
std::basic_istream<CharType> IStream;
typedef
typename
std::basic_string<CharType> StringType;
typedef
typename
boost::spirit::classic::chset<CharType> chset_t;
typedef
typename
boost::spirit::classic::chlit<CharType> chlit_t;
typedef
typename
boost::spirit::classic::scanner<
typename
std::basic_string<CharType>::iterator
> scanner_t;
typedef
typename
boost::spirit::classic::rule<scanner_t> rule_t;
rule_t
Reference,
Eq,
STag,
ETag,
LetterOrUnderscoreOrColon,
AttValue,
CharRef1,
CharRef2,
CharRef,
AmpRef,
LTRef,
GTRef,
AposRef,
QuoteRef,
CharData,
CharDataChars,
content,
AmpName,
LTName,
GTName,
ClassNameChar,
ClassName,
Name,
XMLDecl,
XMLDeclChars,
DocTypeDecl,
DocTypeDeclChars,
ClassIDAttribute,
ObjectIDAttribute,
ClassNameAttribute,
TrackingAttribute,
VersionAttribute,
UnusedAttribute,
Attribute,
SignatureAttribute,
SerializationWrapper,
NameHead,
NameTail,
AttributeList,
S;
chset_t
BaseChar,
Ideographic,
Char,
Letter,
Digit,
CombiningChar,
Extender,
Sch,
NameChar;
void init_chset();
bool my_parse(
IStream & is,
const rule_t &rule_,
const CharType delimiter = L'>'
) const ;
public:
struct return_values {
StringType object_name;
StringType contents;
int_least16_t class_id;
uint_least32_t object_id;
unsigned int version;
tracking_type tracking_level;
StringType class_name;
return_values() :
version(0),
tracking_level(false)
{}
} rv;
bool parse_start_tag(IStream & is) ;
bool parse_end_tag(IStream & is) const;
bool parse_string(IStream & is, StringType & s) ;
void init(IStream & is);
void windup(IStream & is);
basic_xml_grammar();
};
}
}
using namespace boost::spirit::classic;
namespace boost {
namespace archive {
typedef basic_xml_grammar<char> xml_grammar;
template<>
void xml_grammar::init_chset(){
Char = chset_t("\x9\xA\xD\x20-\x7f\x80\x81-\xFF");
Letter = chset_t("\x41-\x5A\x61-\x7A\xC0-\xD6\xD8-\xF6\xF8-\xFF");
Digit = chset_t("0-9");
Extender = chset_t('\xB7');
Sch = chset_t("\x20\x9\xD\xA");
NameChar = Letter | Digit | chset_p("._:-") | Extender ;
}
}
}
namespace boost {
namespace detail {
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 )
;
};
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: };
}
namespace boost
{
template <class T1, class T2>
class compressed_pair;
namespace details
{
template <class T1, class T2, bool IsSame, bool FirstEmpty, bool SecondEmpty>
struct compressed_pair_switch;
template <class T1, class T2>
struct compressed_pair_switch<T1, T2, false, false, false>
{static const int value = 0;};
template <class T1, class T2>
struct compressed_pair_switch<T1, T2, false, true, true>
{static const int value = 3;};
template <class T1, class T2>
struct compressed_pair_switch<T1, T2, false, true, false>
{static const int value = 1;};
template <class T1, class T2>
struct compressed_pair_switch<T1, T2, false, false, true>
{static const int value = 2;};
template <class T1, class T2>
struct compressed_pair_switch<T1, T2, true, true, true>
{static const int value = 4;};
template <class T1, class T2>
struct compressed_pair_switch<T1, T2, true, false, false>
{static const int value = 5;};
template <class T1, class T2, int Version> class compressed_pair_imp;
using std::swap;
template <typename T>
inline void cp_swap(T& t1, T& t2)
{
swap(t1, t2);
}
template <class T1, class T2>
class compressed_pair_imp<T1, T2, 0>
{
public:
typedef T1 first_type;
typedef T2 second_type;
typedef typename call_traits<first_type>::param_type first_param_type;
typedef typename call_traits<second_type>::param_type second_param_type;
typedef typename call_traits<first_type>::reference first_reference;
typedef typename call_traits<second_type>::reference second_reference;
typedef typename call_traits<first_type>::const_reference first_const_reference;
typedef typename call_traits<second_type>::const_reference second_const_reference;
compressed_pair_imp() {}
compressed_pair_imp(first_param_type x, second_param_type y)
: first_(x), second_(y) {}
compressed_pair_imp(first_param_type x)
: first_(x) {}
compressed_pair_imp(second_param_type y)
: second_(y) {}
first_reference first() {return first_;}
first_const_reference first() const {return first_;}
second_reference second() {return second_;}
second_const_reference second() const {return second_;}
void swap(::boost::compressed_pair<T1, T2>& y)
{
cp_swap(first_, y.first());
cp_swap(second_, y.second());
}
private:
first_type first_;
second_type second_;
};
template <class T1, class T2>
class compressed_pair_imp<T1, T2, 1>
: protected ::boost::remove_cv<T1>::type
{
public:
typedef T1 first_type;
typedef T2 second_type;
typedef typename call_traits<first_type>::param_type first_param_type;
typedef typename call_traits<second_type>::param_type second_param_type;
typedef typename call_traits<first_type>::reference first_reference;
typedef typename call_traits<second_type>::reference second_reference;
typedef typename call_traits<first_type>::const_reference first_const_reference;
typedef typename call_traits<second_type>::const_reference second_const_reference;
compressed_pair_imp() {}
compressed_pair_imp(first_param_type x, second_param_type y)
: first_type(x), second_(y) {}
compressed_pair_imp(first_param_type x)
: first_type(x) {}
compressed_pair_imp(second_param_type y)
: second_(y) {}
first_reference first() {return *this;}
first_const_reference first() const {return *this;}
second_reference second() {return second_;}
second_const_reference second() const {return second_;}
void swap(::boost::compressed_pair<T1,T2>& y)
{
cp_swap(second_, y.second());
}
private:
second_type second_;
};
template <class T1, class T2>
class compressed_pair_imp<T1, T2, 2>
: protected ::boost::remove_cv<T2>::type
{
public:
typedef T1 first_type;
typedef T2 second_type;
typedef typename call_traits<first_type>::param_type first_param_type;
typedef typename call_traits<second_type>::param_type second_param_type;
typedef typename call_traits<first_type>::reference first_reference;
typedef typename call_traits<second_type>::reference second_reference;
typedef typename call_traits<first_type>::const_reference first_const_reference;
typedef typename call_traits<second_type>::const_reference second_const_reference;
compressed_pair_imp() {}
compressed_pair_imp(first_param_type x, second_param_type y)
: second_type(y), first_(x) {}
compressed_pair_imp(first_param_type x)
: first_(x) {}
compressed_pair_imp(second_param_type y)
: second_type(y) {}
first_reference first() {return first_;}
first_const_reference first() const {return first_;}
second_reference second() {return *this;}
second_const_reference second() const {return *this;}
void swap(::boost::compressed_pair<T1,T2>& y)
{
cp_swap(first_, y.first());
}
private:
first_type first_;
};
template <class T1, class T2>
class compressed_pair_imp<T1, T2, 3>
: protected ::boost::remove_cv<T1>::type,
protected ::boost::remove_cv<T2>::type
{
public:
typedef T1 first_type;
typedef T2 second_type;
typedef typename call_traits<first_type>::param_type first_param_type;
typedef typename call_traits<second_type>::param_type second_param_type;
typedef typename call_traits<first_type>::reference first_reference;
typedef typename call_traits<second_type>::reference second_reference;
typedef typename call_traits<first_type>::const_reference first_const_reference;
typedef typename call_traits<second_type>::const_reference second_const_reference;
compressed_pair_imp() {}
compressed_pair_imp(first_param_type x, second_param_type y)
: first_type(x), second_type(y) {}
compressed_pair_imp(first_param_type x)
: first_type(x) {}
compressed_pair_imp(second_param_type y)
: second_type(y) {}
first_reference first() {return *this;}
first_const_reference first() const {return *this;}
second_reference second() {return *this;}
second_const_reference second() const {return *this;}
void swap(::boost::compressed_pair<T1,T2>&) {}
};
template <class T1, class T2>
class compressed_pair_imp<T1, T2, 4>
: protected ::boost::remove_cv<T1>::type
{
public:
typedef T1 first_type;
typedef T2 second_type;
typedef typename call_traits<first_type>::param_type first_param_type;
typedef typename call_traits<second_type>::param_type second_param_type;
typedef typename call_traits<first_type>::reference first_reference;
typedef typename call_traits<second_type>::reference second_reference;
typedef typename call_traits<first_type>::const_reference first_const_reference;
typedef typename call_traits<second_type>::const_reference second_const_reference;
compressed_pair_imp() {}
compressed_pair_imp(first_param_type x, second_param_type y)
: first_type(x), m_second(y) {}
compressed_pair_imp(first_param_type x)
: first_type(x), m_second(x) {}
first_reference first() {return *this;}
first_const_reference first() const {return *this;}
second_reference second() {return m_second;}
second_const_reference second() const {return m_second;}
void swap(::boost::compressed_pair<T1,T2>&) {}
private:
T2 m_second;
};
template <class T1, class T2>
class compressed_pair_imp<T1, T2, 5>
{
public:
typedef T1 first_type;
typedef T2 second_type;
typedef typename call_traits<first_type>::param_type first_param_type;
typedef typename call_traits<second_type>::param_type second_param_type;
typedef typename call_traits<first_type>::reference first_reference;
typedef typename call_traits<second_type>::reference second_reference;
typedef typename call_traits<first_type>::const_reference first_const_reference;
typedef typename call_traits<second_type>::const_reference second_const_reference;
compressed_pair_imp() {}
compressed_pair_imp(first_param_type x, second_param_type y)
: first_(x), second_(y) {}
compressed_pair_imp(first_param_type x)
: first_(x), second_(x) {}
first_reference first() {return first_;}
first_const_reference first() const {return first_;}
second_reference second() {return second_;}
second_const_reference second() const {return second_;}
void swap(::boost::compressed_pair<T1, T2>& y)
{
cp_swap(first_, y.first());
cp_swap(second_, y.second());
}
private:
first_type first_;
second_type second_;
};
}
template <class T1, class T2>
class compressed_pair
: private ::boost::details::compressed_pair_imp<T1, T2,
::boost::details::compressed_pair_switch<
T1,
T2,
::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
::boost::is_empty<T1>::value,
::boost::is_empty<T2>::value>::value>
{
private:
typedef details::compressed_pair_imp<T1, T2,
::boost::details::compressed_pair_switch<
T1,
T2,
::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
::boost::is_empty<T1>::value,
::boost::is_empty<T2>::value>::value> base;
public:
typedef T1 first_type;
typedef T2 second_type;
typedef typename call_traits<first_type>::param_type first_param_type;
typedef typename call_traits<second_type>::param_type second_param_type;
typedef typename call_traits<first_type>::reference first_reference;
typedef typename call_traits<second_type>::reference second_reference;
typedef typename call_traits<first_type>::const_reference first_const_reference;
typedef typename call_traits<second_type>::const_reference second_const_reference;
compressed_pair() : base() {}
compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
explicit compressed_pair(first_param_type x) : base(x) {}
explicit compressed_pair(second_param_type y) : base(y) {}
first_reference first() {return base::first();}
first_const_reference first() const {return base::first();}
second_reference second() {return base::second();}
second_const_reference second() const {return base::second();}
void swap(compressed_pair& y) { base::swap(y); }
};
template <class T>
class compressed_pair<T, T>
: private details::compressed_pair_imp<T, T,
::boost::details::compressed_pair_switch<
T,
T,
::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
::boost::is_empty<T>::value,
::boost::is_empty<T>::value>::value>
{
private:
typedef details::compressed_pair_imp<T, T,
::boost::details::compressed_pair_switch<
T,
T,
::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
::boost::is_empty<T>::value,
::boost::is_empty<T>::value>::value> base;
public:
typedef T first_type;
typedef T second_type;
typedef typename call_traits<first_type>::param_type first_param_type;
typedef typename call_traits<second_type>::param_type second_param_type;
typedef typename call_traits<first_type>::reference first_reference;
typedef typename call_traits<second_type>::reference second_reference;
typedef typename call_traits<first_type>::const_reference first_const_reference;
typedef typename call_traits<second_type>::const_reference second_const_reference;
compressed_pair() : base() {}
compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
explicit
compressed_pair(first_param_type x) : base(x) {}
first_reference first() {return base::first();}
first_const_reference first() const {return base::first();}
second_reference second() {return base::second();}
second_const_reference second() const {return base::second();}
void swap(::boost::compressed_pair<T,T>& y) { base::swap(y); }
};
template <class T1, class T2>
inline
void
swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
{
x.swap(y);
}
}
namespace boost { namespace spirit {
namespace classic {
template <typename S, typename BaseT>
class unary : public BaseT
{
public:
typedef BaseT base_t;
typedef typename boost::call_traits<S>::param_type param_t;
typedef typename boost::call_traits<S>::const_reference return_t;
typedef S subject_t;
typedef typename S::embed_t subject_embed_t;
unary(param_t subj_)
: base_t(), subj(subj_) {}
unary(BaseT const& base, param_t subj_)
: base_t(base), subj(subj_) {}
return_t
subject() const
{ return subj; }
private:
subject_embed_t subj;
};
template <typename A, typename B, typename BaseT>
class binary : public BaseT
{
public:
typedef BaseT base_t;
typedef typename boost::call_traits<A>::param_type left_param_t;
typedef typename boost::call_traits<A>::const_reference left_return_t;
typedef typename boost::call_traits<B>::param_type right_param_t;
typedef typename boost::call_traits<B>::const_reference right_return_t;
typedef A left_t;
typedef typename A::embed_t left_embed_t;
typedef B right_t;
typedef typename B::embed_t right_embed_t;
binary(left_param_t a, right_param_t b)
: base_t(), subj(a, b) {}
left_return_t
left() const
{ return subj.first(); }
right_return_t
right() const
{ return subj.second(); }
private:
boost::compressed_pair<left_embed_t, right_embed_t> subj;
};
}
}}
namespace boost { namespace spirit {
namespace classic {
namespace impl
{
template<typename T>
struct default_as_parser
{
typedef T type;
static type const& convert(type const& p)
{
return p;
}
};
struct char_as_parser
{
typedef chlit<char> type;
static type convert(char ch)
{
return type(ch);
}
};
struct wchar_as_parser
{
typedef chlit<wchar_t> type;
static type convert(wchar_t ch)
{
return type(ch);
}
};
struct string_as_parser
{
typedef strlit<char const*> type;
static type convert(char const* str)
{
return type(str);
}
};
struct wstring_as_parser
{
typedef strlit<wchar_t const*> type;
static type convert(wchar_t const* str)
{
return type(str);
}
};
}
template<typename T>
struct as_parser : impl::default_as_parser<T> {};
template<>
struct as_parser<char> : impl::char_as_parser {};
template<>
struct as_parser<wchar_t> : impl::wchar_as_parser {};
template<>
struct as_parser<char*> : impl::string_as_parser {};
template<>
struct as_parser<char const*> : impl::string_as_parser {};
template<>
struct as_parser<wchar_t*> : impl::wstring_as_parser {};
template<>
struct as_parser<wchar_t const*> : impl::wstring_as_parser {};
template<int N>
struct as_parser<char[N]> : impl::string_as_parser {};
template<int N>
struct as_parser<wchar_t[N]> : impl::wstring_as_parser {};
template<int N>
struct as_parser<char const[N]> : impl::string_as_parser {};
template<int N>
struct as_parser<wchar_t const[N]> : impl::wstring_as_parser {};
}
}}
namespace boost { namespace spirit {
namespace classic {
struct sequence_parser_gen;
template <typename A, typename B>
struct sequence : public binary<A, B, parser<sequence<A, B> > >
{
typedef sequence<A, B> self_t;
typedef binary_parser_category parser_category_t;
typedef sequence_parser_gen parser_generator_t;
typedef binary<A, B, parser<self_t> > base_t;
sequence(A const& a, B const& b)
: base_t(a, b) {}
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typedef typename parser_result<self_t, ScannerT>::type result_t;
if (result_t ma = this->left().parse(scan))
if (result_t mb = this->right().parse(scan))
{
scan.concat_match(ma, mb);
return ma;
}
return scan.no_match();
}
};
struct sequence_parser_gen
{
template <typename A, typename B>
struct result
{
typedef
sequence<
typename as_parser<A>::type
, typename as_parser<B>::type
>
type;
};
template <typename A, typename B>
static sequence<
typename as_parser<A>::type
, typename as_parser<B>::type
>
generate(A const& a, B const& b)
{
return sequence<
typename
as_parser<A>::type,
typename
as_parser<B>::type>
(as_parser<A>::convert(a), as_parser<B>::convert(b));
}
};
template <typename A, typename B>
sequence<A, B>
operator>>(parser<A> const& a, parser<B> const& b);
template <typename A>
sequence<A, chlit<char> >
operator>>(parser<A> const& a, char b);
template <typename B>
sequence<chlit<char>, B>
operator>>(char a, parser<B> const& b);
template <typename A>
sequence<A, strlit<char const*> >
operator>>(parser<A> const& a, char const* b);
template <typename B>
sequence<strlit<char const*>, B>
operator>>(char const* a, parser<B> const& b);
template <typename A>
sequence<A, chlit<wchar_t> >
operator>>(parser<A> const& a, wchar_t b);
template <typename B>
sequence<chlit<wchar_t>, B>
operator>>(wchar_t a, parser<B> const& b);
template <typename A>
sequence<A, strlit<wchar_t const*> >
operator>>(parser<A> const& a, wchar_t const* b);
template <typename B>
sequence<strlit<wchar_t const*>, B>
operator>>(wchar_t const* a, parser<B> const& b);
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename A, typename B>
inline sequence<A, B>
operator>>(parser<A> const& a, parser<B> const& b)
{
return sequence<A, B>(a.derived(), b.derived());
}
template <typename A>
inline sequence<A, chlit<char> >
operator>>(parser<A> const& a, char b)
{
return sequence<A, chlit<char> >(a.derived(), b);
}
template <typename B>
inline sequence<chlit<char>, B>
operator>>(char a, parser<B> const& b)
{
return sequence<chlit<char>, B>(a, b.derived());
}
template <typename A>
inline sequence<A, strlit<char const*> >
operator>>(parser<A> const& a, char const* b)
{
return sequence<A, strlit<char const*> >(a.derived(), b);
}
template <typename B>
inline sequence<strlit<char const*>, B>
operator>>(char const* a, parser<B> const& b)
{
return sequence<strlit<char const*>, B>(a, b.derived());
}
template <typename A>
inline sequence<A, chlit<wchar_t> >
operator>>(parser<A> const& a, wchar_t b)
{
return sequence<A, chlit<wchar_t> >(a.derived(), b);
}
template <typename B>
inline sequence<chlit<wchar_t>, B>
operator>>(wchar_t a, parser<B> const& b)
{
return sequence<chlit<wchar_t>, B>(a, b.derived());
}
template <typename A>
inline sequence<A, strlit<wchar_t const*> >
operator>>(parser<A> const& a, wchar_t const* b)
{
return sequence<A, strlit<wchar_t const*> >(a.derived(), b);
}
template <typename B>
inline sequence<strlit<wchar_t const*>, B>
operator>>(wchar_t const* a, parser<B> const& b)
{
return sequence<strlit<wchar_t const*>, B>(a, b.derived());
}
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename A, typename B>
sequence<A, B>
operator&&(parser<A> const& a, parser<B> const& b);
template <typename A>
sequence<A, chlit<char> >
operator&&(parser<A> const& a, char b);
template <typename B>
sequence<chlit<char>, B>
operator&&(char a, parser<B> const& b);
template <typename A>
sequence<A, strlit<char const*> >
operator&&(parser<A> const& a, char const* b);
template <typename B>
sequence<strlit<char const*>, B>
operator&&(char const* a, parser<B> const& b);
template <typename A>
sequence<A, chlit<wchar_t> >
operator&&(parser<A> const& a, wchar_t b);
template <typename B>
sequence<chlit<wchar_t>, B>
operator&&(wchar_t a, parser<B> const& b);
template <typename A>
sequence<A, strlit<wchar_t const*> >
operator&&(parser<A> const& a, wchar_t const* b);
template <typename B>
sequence<strlit<wchar_t const*>, B>
operator&&(wchar_t const* a, parser<B> const& b);
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename A, typename B>
inline sequence<A, B>
operator&&(parser<A> const& a, parser<B> const& b)
{
return sequence<A, B>(a.derived(), b.derived());
}
template <typename A>
inline sequence<A, chlit<char> >
operator&&(parser<A> const& a, char b)
{
return sequence<A, chlit<char> >(a.derived(), b);
}
template <typename B>
inline sequence<chlit<char>, B>
operator&&(char a, parser<B> const& b)
{
return sequence<chlit<char>, B>(a, b.derived());
}
template <typename A>
inline sequence<A, strlit<char const*> >
operator&&(parser<A> const& a, char const* b)
{
return sequence<A, strlit<char const*> >(a.derived(), b);
}
template <typename B>
inline sequence<strlit<char const*>, B>
operator&&(char const* a, parser<B> const& b)
{
return sequence<strlit<char const*>, B>(a, b.derived());
}
template <typename A>
inline sequence<A, chlit<wchar_t> >
operator&&(parser<A> const& a, wchar_t b)
{
return sequence<A, chlit<wchar_t> >(a.derived(), b);
}
template <typename B>
inline sequence<chlit<wchar_t>, B>
operator&&(wchar_t a, parser<B> const& b)
{
return sequence<chlit<wchar_t>, B>(a, b.derived());
}
template <typename A>
inline sequence<A, strlit<wchar_t const*> >
operator&&(parser<A> const& a, wchar_t const* b)
{
return sequence<A, strlit<wchar_t const*> >(a.derived(), b);
}
template <typename B>
inline sequence<strlit<wchar_t const*>, B>
operator&&(wchar_t const* a, parser<B> const& b)
{
return sequence<strlit<wchar_t const*>, B>(a, b.derived());
}
}
}}
namespace boost { namespace spirit {
namespace classic {
struct sequential_or_parser_gen;
template <typename A, typename B>
struct sequential_or : public binary<A, B, parser<sequential_or<A, B> > >
{
typedef sequential_or<A, B> self_t;
typedef binary_parser_category parser_category_t;
typedef sequential_or_parser_gen parser_generator_t;
typedef binary<A, B, parser<self_t> > base_t;
sequential_or(A const& a, B const& b)
: base_t(a, b) {}
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typedef typename parser_result<self_t, ScannerT>::type result_t;
typedef typename ScannerT::iterator_t iterator_t;
{
iterator_t save = scan.first;
if (result_t ma = this->left().parse(scan))
{
save = scan.first;
if (result_t mb = this->right().parse(scan))
{
scan.concat_match(ma, mb);
return ma;
}
else
{
scan.first = save;
return ma;
}
}
scan.first = save;
}
return this->right().parse(scan);
}
};
struct sequential_or_parser_gen
{
template <typename A, typename B>
struct result
{
typedef
sequential_or<
typename as_parser<A>::type
, typename as_parser<B>::type
>
type;
};
template <typename A, typename B>
static sequential_or<
typename as_parser<A>::type
, typename as_parser<B>::type
>
generate(A const& a, B const& b)
{
return sequential_or<
typename
as_parser<A>::type,
typename
as_parser<B>::type>
(as_parser<A>::convert(a), as_parser<B>::convert(b));
}
};
template <typename A, typename B>
sequential_or<A, B>
operator||(parser<A> const& a, parser<B> const& b);
template <typename A>
sequential_or<A, chlit<char> >
operator||(parser<A> const& a, char b);
template <typename B>
sequential_or<chlit<char>, B>
operator||(char a, parser<B> const& b);
template <typename A>
sequential_or<A, strlit<char const*> >
operator||(parser<A> const& a, char const* b);
template <typename B>
sequential_or<strlit<char const*>, B>
operator||(char const* a, parser<B> const& b);
template <typename A>
sequential_or<A, chlit<wchar_t> >
operator||(parser<A> const& a, wchar_t b);
template <typename B>
sequential_or<chlit<wchar_t>, B>
operator||(wchar_t a, parser<B> const& b);
template <typename A>
sequential_or<A, strlit<wchar_t const*> >
operator||(parser<A> const& a, wchar_t const* b);
template <typename B>
sequential_or<strlit<wchar_t const*>, B>
operator||(wchar_t const* a, parser<B> const& b);
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename A, typename B>
inline sequential_or<A, B>
operator||(parser<A> const& a, parser<B> const& b)
{
return sequential_or<A, B>(a.derived(), b.derived());
}
template <typename A>
inline sequential_or<A, chlit<char> >
operator||(parser<A> const& a, char b)
{
return sequential_or<A, chlit<char> >(a.derived(), b);
}
template <typename B>
inline sequential_or<chlit<char>, B>
operator||(char a, parser<B> const& b)
{
return sequential_or<chlit<char>, B>(a, b.derived());
}
template <typename A>
inline sequential_or<A, strlit<char const*> >
operator||(parser<A> const& a, char const* b)
{
return sequential_or<A, strlit<char const*> >(a.derived(), b);
}
template <typename B>
inline sequential_or<strlit<char const*>, B>
operator||(char const* a, parser<B> const& b)
{
return sequential_or<strlit<char const*>, B>(a, b.derived());
}
template <typename A>
inline sequential_or<A, chlit<wchar_t> >
operator||(parser<A> const& a, wchar_t b)
{
return sequential_or<A, chlit<wchar_t> >(a.derived(), b);
}
template <typename B>
inline sequential_or<chlit<wchar_t>, B>
operator||(wchar_t a, parser<B> const& b)
{
return sequential_or<chlit<wchar_t>, B>(a, b.derived());
}
template <typename A>
inline sequential_or<A, strlit<wchar_t const*> >
operator||(parser<A> const& a, wchar_t const* b)
{
return sequential_or<A, strlit<wchar_t const*> >(a.derived(), b);
}
template <typename B>
inline sequential_or<strlit<wchar_t const*>, B>
operator||(wchar_t const* a, parser<B> const& b)
{
return sequential_or<strlit<wchar_t const*>, B>(a, b.derived());
}
}
}}
namespace boost { namespace spirit {
namespace classic {
struct alternative_parser_gen;
template <typename A, typename B>
struct alternative
: public binary<A, B, parser<alternative<A, B> > >
{
typedef alternative<A, B> self_t;
typedef binary_parser_category parser_category_t;
typedef alternative_parser_gen parser_generator_t;
typedef binary<A, B, parser<self_t> > base_t;
alternative(A const& a, B const& b)
: base_t(a, b) {}
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typedef typename parser_result<self_t, ScannerT>::type result_t;
typedef typename ScannerT::iterator_t iterator_t;
{
iterator_t save = scan.first;
if (result_t hit = this->left().parse(scan))
return hit;
scan.first = save;
}
return this->right().parse(scan);
}
};
struct alternative_parser_gen
{
template <typename A, typename B>
struct result
{
typedef
alternative<
typename as_parser<A>::type
, typename as_parser<B>::type
>
type;
};
template <typename A, typename B>
static alternative<
typename as_parser<A>::type
, typename as_parser<B>::type
>
generate(A const& a, B const& b)
{
return alternative<
typename
as_parser<A>::type,
typename
as_parser<B>::type>
(as_parser<A>::convert(a), as_parser<B>::convert(b));
}
};
template <typename A, typename B>
alternative<A, B>
operator|(parser<A> const& a, parser<B> const& b);
template <typename A>
alternative<A, chlit<char> >
operator|(parser<A> const& a, char b);
template <typename B>
alternative<chlit<char>, B>
operator|(char a, parser<B> const& b);
template <typename A>
alternative<A, strlit<char const*> >
operator|(parser<A> const& a, char const* b);
template <typename B>
alternative<strlit<char const*>, B>
operator|(char const* a, parser<B> const& b);
template <typename A>
alternative<A, chlit<wchar_t> >
operator|(parser<A> const& a, wchar_t b);
template <typename B>
alternative<chlit<wchar_t>, B>
operator|(wchar_t a, parser<B> const& b);
template <typename A>
alternative<A, strlit<wchar_t const*> >
operator|(parser<A> const& a, wchar_t const* b);
template <typename B>
alternative<strlit<wchar_t const*>, B>
operator|(wchar_t const* a, parser<B> const& b);
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename A, typename B>
inline alternative<A, B>
operator|(parser<A> const& a, parser<B> const& b)
{
return alternative<A, B>(a.derived(), b.derived());
}
template <typename A>
inline alternative<A, chlit<char> >
operator|(parser<A> const& a, char b)
{
return alternative<A, chlit<char> >(a.derived(), b);
}
template <typename B>
inline alternative<chlit<char>, B>
operator|(char a, parser<B> const& b)
{
return alternative<chlit<char>, B>(a, b.derived());
}
template <typename A>
inline alternative<A, strlit<char const*> >
operator|(parser<A> const& a, char const* b)
{
return alternative<A, strlit<char const*> >(a.derived(), b);
}
template <typename B>
inline alternative<strlit<char const*>, B>
operator|(char const* a, parser<B> const& b)
{
return alternative<strlit<char const*>, B>(a, b.derived());
}
template <typename A>
inline alternative<A, chlit<wchar_t> >
operator|(parser<A> const& a, wchar_t b)
{
return alternative<A, chlit<wchar_t> >(a.derived(), b);
}
template <typename B>
inline alternative<chlit<wchar_t>, B>
operator|(wchar_t a, parser<B> const& b)
{
return alternative<chlit<wchar_t>, B>(a, b.derived());
}
template <typename A>
inline alternative<A, strlit<wchar_t const*> >
operator|(parser<A> const& a, wchar_t const* b)
{
return alternative<A, strlit<wchar_t const*> >(a.derived(), b);
}
template <typename B>
inline alternative<strlit<wchar_t const*>, B>
operator|(wchar_t const* a, parser<B> const& b)
{
return alternative<strlit<wchar_t const*>, B>(a, b.derived());
}
}
}}
namespace boost { namespace spirit {
namespace classic {
struct difference_parser_gen;
template <typename A, typename B>
struct difference
: public binary<A, B, parser<difference<A, B> > >
{
typedef difference<A, B> self_t;
typedef binary_parser_category parser_category_t;
typedef difference_parser_gen parser_generator_t;
typedef binary<A, B, parser<self_t> > base_t;
difference(A const& a, B const& b)
: base_t(a, b) {}
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typedef typename parser_result<self_t, ScannerT>::type result_t;
typedef typename ScannerT::iterator_t iterator_t;
iterator_t save = scan.first;
if (result_t hl = this->left().parse(scan))
{
std::swap(save, scan.first);
result_t hr = this->right().parse(scan);
if (!hr || (hr.length() < hl.length()))
{
scan.first = save;
return hl;
}
}
return scan.no_match();
}
};
struct difference_parser_gen
{
template <typename A, typename B>
struct result
{
typedef
difference<
typename as_parser<A>::type
, typename as_parser<B>::type
>
type;
};
template <typename A, typename B>
static difference<
typename as_parser<A>::type
, typename as_parser<B>::type
>
generate(A const& a, B const& b)
{
return difference<
typename
as_parser<A>::type,
typename
as_parser<B>::type>
(as_parser<A>::convert(a), as_parser<B>::convert(b));
}
};
template <typename A, typename B>
difference<A, B>
operator-(parser<A> const& a, parser<B> const& b);
template <typename A>
difference<A, chlit<char> >
operator-(parser<A> const& a, char b);
template <typename B>
difference<chlit<char>, B>
operator-(char a, parser<B> const& b);
template <typename A>
difference<A, strlit<char const*> >
operator-(parser<A> const& a, char const* b);
template <typename B>
difference<strlit<char const*>, B>
operator-(char const* a, parser<B> const& b);
template <typename A>
difference<A, chlit<wchar_t> >
operator-(parser<A> const& a, wchar_t b);
template <typename B>
difference<chlit<wchar_t>, B>
operator-(wchar_t a, parser<B> const& b);
template <typename A>
difference<A, strlit<wchar_t const*> >
operator-(parser<A> const& a, wchar_t const* b);
template <typename B>
difference<strlit<wchar_t const*>, B>
operator-(wchar_t const* a, parser<B> const& b);
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename A, typename B>
inline difference<A, B>
operator-(parser<A> const& a, parser<B> const& b)
{
return difference<A, B>(a.derived(), b.derived());
}
template <typename A>
inline difference<A, chlit<char> >
operator-(parser<A> const& a, char b)
{
return difference<A, chlit<char> >(a.derived(), b);
}
template <typename B>
inline difference<chlit<char>, B>
operator-(char a, parser<B> const& b)
{
return difference<chlit<char>, B>(a, b.derived());
}
template <typename A>
inline difference<A, strlit<char const*> >
operator-(parser<A> const& a, char const* b)
{
return difference<A, strlit<char const*> >(a.derived(), b);
}
template <typename B>
inline difference<strlit<char const*>, B>
operator-(char const* a, parser<B> const& b)
{
return difference<strlit<char const*>, B>(a, b.derived());
}
template <typename A>
inline difference<A, chlit<wchar_t> >
operator-(parser<A> const& a, wchar_t b)
{
return difference<A, chlit<wchar_t> >(a.derived(), b);
}
template <typename B>
inline difference<chlit<wchar_t>, B>
operator-(wchar_t a, parser<B> const& b)
{
return difference<chlit<wchar_t>, B>(a, b.derived());
}
template <typename A>
difference<A, strlit<wchar_t const*> >
operator-(parser<A> const& a, wchar_t const* b)
;
template <typename B>
difference<strlit<wchar_t const*>, B>
operator-(wchar_t const* a, parser<B> const& b)
;
}
}}
namespace boost { namespace spirit {
namespace classic {
struct intersection_parser_gen;
template <typename A, typename B>
struct intersection
: public binary<A, B, parser<intersection<A, B> > >
{
typedef intersection<A, B> self_t;
typedef binary_parser_category parser_category_t;
typedef intersection_parser_gen parser_generator_t;
typedef binary<A, B, parser<self_t> > base_t;
intersection(A const& a, B const& b) ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
struct intersection_parser_gen
{
template <typename A, typename B>
struct result
{
typedef
intersection<
typename as_parser<A>::type
, typename as_parser<B>::type
>
type;
};
template <typename A, typename B>
static intersection<
typename as_parser<A>::type
, typename as_parser<B>::type
>
generate(A const& a, B const& b)
;
};
template <typename A, typename B>
intersection<A, B>
operator&(parser<A> const& a, parser<B> const& b);
template <typename A>
intersection<A, chlit<char> >
operator&(parser<A> const& a, char b);
template <typename B>
intersection<chlit<char>, B>
operator&(char a, parser<B> const& b);
template <typename A>
intersection<A, strlit<char const*> >
operator&(parser<A> const& a, char const* b);
template <typename B>
intersection<strlit<char const*>, B>
operator&(char const* a, parser<B> const& b);
template <typename A>
intersection<A, chlit<wchar_t> >
operator&(parser<A> const& a, wchar_t b);
template <typename B>
intersection<chlit<wchar_t>, B>
operator&(wchar_t a, parser<B> const& b);
template <typename A>
intersection<A, strlit<wchar_t const*> >
operator&(parser<A> const& a, wchar_t const* b);
template <typename B>
intersection<strlit<wchar_t const*>, B>
operator&(wchar_t const* a, parser<B> const& b);
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename A, typename B>
intersection<A, B>
operator&(parser<A> const& a, parser<B> const& b)
;
template <typename A>
intersection<A, chlit<char> >
operator&(parser<A> const& a, char b)
;
template <typename B>
intersection<chlit<char>, B>
operator&(char a, parser<B> const& b)
;
template <typename A>
intersection<A, strlit<char const*> >
operator&(parser<A> const& a, char const* b)
;
template <typename B>
intersection<strlit<char const*>, B>
operator&(char const* a, parser<B> const& b)
;
template <typename A>
intersection<A, chlit<wchar_t> >
operator&(parser<A> const& a, wchar_t b)
;
template <typename B>
intersection<chlit<wchar_t>, B>
operator&(wchar_t a, parser<B> const& b)
;
template <typename A>
intersection<A, strlit<wchar_t const*> >
operator&(parser<A> const& a, wchar_t const* b)
;
template <typename B>
intersection<strlit<wchar_t const*>, B>
operator&(wchar_t const* a, parser<B> const& b)
;
}
}}
namespace boost { namespace spirit {
namespace classic {
struct exclusive_or_parser_gen;
template <typename A, typename B>
struct exclusive_or
: public binary<A, B, parser<exclusive_or<A, B> > >
{
typedef exclusive_or<A, B> self_t;
typedef binary_parser_category parser_category_t;
typedef exclusive_or_parser_gen parser_generator_t;
typedef binary<A, B, parser<self_t> > base_t;
exclusive_or(A const& a, B const& b) ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
struct exclusive_or_parser_gen
{
template <typename A, typename B>
struct result
{
typedef
exclusive_or<
typename as_parser<A>::type
, typename as_parser<B>::type
>
type;
};
template <typename A, typename B>
static exclusive_or<
typename as_parser<A>::type
, typename as_parser<B>::type
>
generate(A const& a, B const& b)
;
};
template <typename A, typename B>
exclusive_or<A, B>
operator^(parser<A> const& a, parser<B> const& b);
template <typename A>
exclusive_or<A, chlit<char> >
operator^(parser<A> const& a, char b);
template <typename B>
exclusive_or<chlit<char>, B>
operator^(char a, parser<B> const& b);
template <typename A>
exclusive_or<A, strlit<char const*> >
operator^(parser<A> const& a, char const* b);
template <typename B>
exclusive_or<strlit<char const*>, B>
operator^(char const* a, parser<B> const& b);
template <typename A>
exclusive_or<A, chlit<wchar_t> >
operator^(parser<A> const& a, wchar_t b);
template <typename B>
exclusive_or<chlit<wchar_t>, B>
operator^(wchar_t a, parser<B> const& b);
template <typename A>
exclusive_or<A, strlit<wchar_t const*> >
operator^(parser<A> const& a, wchar_t const* b);
template <typename B>
exclusive_or<strlit<wchar_t const*>, B>
operator^(wchar_t const* a, parser<B> const& b);
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename A, typename B>
exclusive_or<A, B>
operator^(parser<A> const& a, parser<B> const& b)
;
template <typename A>
exclusive_or<A, chlit<char> >
operator^(parser<A> const& a, char b)
;
template <typename B>
exclusive_or<chlit<char>, B>
operator^(char a, parser<B> const& b)
;
template <typename A>
exclusive_or<A, strlit<char const*> >
operator^(parser<A> const& a, char const* b)
;
template <typename B>
exclusive_or<strlit<char const*>, B>
operator^(char const* a, parser<B> const& b)
;
template <typename A>
exclusive_or<A, chlit<wchar_t> >
operator^(parser<A> const& a, wchar_t b)
;
template <typename B>
exclusive_or<chlit<wchar_t>, B>
operator^(wchar_t a, parser<B> const& b)
;
template <typename A>
exclusive_or<A, strlit<wchar_t const*> >
operator^(parser<A> const& a, wchar_t const* b)
;
template <typename B>
exclusive_or<strlit<wchar_t const*>, B>
operator^(wchar_t const* a, parser<B> const& b)
;
}
}}
namespace boost { namespace spirit {
namespace classic {
struct kleene_star_parser_gen;
template <typename S>
struct kleene_star
: public unary<S, parser<kleene_star<S> > >
{
typedef kleene_star<S> self_t;
typedef unary_parser_category parser_category_t;
typedef kleene_star_parser_gen parser_generator_t;
typedef unary<S, parser<self_t> > base_t;
kleene_star(S const& a) ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
struct kleene_star_parser_gen
{
template <typename S>
struct result
{
typedef kleene_star<S> type;
};
template <typename S>
static kleene_star<S>
generate(parser<S> const& a)
;
};
template <typename S>
kleene_star<S>
operator*(parser<S> const& a);
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename S>
kleene_star<S>
operator*(parser<S> const& a)
;
}
}}
namespace boost { namespace spirit {
namespace classic {
struct positive_parser_gen;
template <typename S>
struct positive
: public unary<S, parser<positive<S> > >
{
typedef positive<S> self_t;
typedef unary_parser_category parser_category_t;
typedef positive_parser_gen parser_generator_t;
typedef unary<S, parser<self_t> > base_t;
positive(S const& a) ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
struct positive_parser_gen
{
template <typename S>
struct result
{
typedef positive<S> type;
};
template <typename S>
static positive<S>
generate(parser<S> const& a)
;
};
template <typename S>
positive<S>
operator+(parser<S> const& a);
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename S>
positive<S>
operator+(parser<S> const& a)
;
}
}}
namespace boost { namespace spirit {
namespace classic {
struct optional_parser_gen;
template <typename S>
struct optional
: public unary<S, parser<optional<S> > >
{
typedef optional<S> self_t;
typedef unary_parser_category parser_category_t;
typedef optional_parser_gen parser_generator_t;
typedef unary<S, parser<self_t> > base_t;
optional(S const& a) ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
struct optional_parser_gen
{
template <typename S>
struct result
{
typedef optional<S> type;
};
template <typename S>
static optional<S>
generate(parser<S> const& a)
;
};
template <typename S>
optional<S>
operator!(parser<S> const& a);
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename S>
optional<S>
operator!(parser<S> const& a)
;
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename A, typename B>
sequence<A, kleene_star<sequence<B, A> > >
operator%(parser<A> const& a, parser<B> const& b);
template <typename A>
sequence<A, kleene_star<sequence<chlit<char>, A> > >
operator%(parser<A> const& a, char b);
template <typename B>
sequence<chlit<char>, kleene_star<sequence<B, chlit<char> > > >
operator%(char a, parser<B> const& b);
template <typename A>
sequence<A, kleene_star<sequence<strlit<char const*>, A> > >
operator%(parser<A> const& a, char const* b);
template <typename B>
sequence<strlit<char const*>,
kleene_star<sequence<B, strlit<char const*> > > >
operator%(char const* a, parser<B> const& b);
template <typename A>
sequence<A, kleene_star<sequence<chlit<wchar_t>, A> > >
operator%(parser<A> const& a, wchar_t b);
template <typename B>
sequence<chlit<wchar_t>, kleene_star<sequence<B, chlit<wchar_t> > > >
operator%(wchar_t a, parser<B> const& b);
template <typename A>
sequence<A, kleene_star<sequence<strlit<wchar_t const*>, A> > >
operator%(parser<A> const& a, wchar_t const* b);
template <typename B>
sequence<strlit<wchar_t const*>,
kleene_star<sequence<B, strlit<wchar_t const*> > > >
operator%(wchar_t const* a, parser<B> const& b);
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename A, typename B>
sequence<A, kleene_star<sequence<B, A> > >
operator%(parser<A> const& a, parser<B> const& b)
;
template <typename A>
sequence<A, kleene_star<sequence<chlit<char>, A> > >
operator%(parser<A> const& a, char b)
;
template <typename B>
sequence<chlit<char>, kleene_star<sequence<B, chlit<char> > > >
operator%(char a, parser<B> const& b)
;
template <typename A>
sequence<A, kleene_star<sequence<strlit<char const*>, A> > >
operator%(parser<A> const& a, char const* b)
;
template <typename B>
sequence<strlit<char const*>,
kleene_star<sequence<B, strlit<char const*> > > >
operator%(char const* a, parser<B> const& b)
;
template <typename A>
sequence<A, kleene_star<sequence<chlit<wchar_t>, A> > >
operator%(parser<A> const& a, wchar_t b)
;
template <typename B>
sequence<chlit<wchar_t>, kleene_star<sequence<B, chlit<wchar_t> > > >
operator%(wchar_t a, parser<B> const& b)
;
template <typename A>
sequence<A, kleene_star<sequence<strlit<wchar_t const*>, A> > >
operator%(parser<A> const& a, wchar_t const* b)
;
template <typename B>
sequence<strlit<wchar_t const*>,
kleene_star<sequence<B, strlit<wchar_t const*> > > >
operator%(wchar_t const* a, parser<B> const& b)
;
}
}}
namespace boost { namespace spirit {
namespace classic {
template <typename ParserT, typename ActionT>
class action : public unary<ParserT, parser<action<ParserT, ActionT> > >
{
public:
typedef action<ParserT, ActionT> self_t;
typedef action_parser_category parser_category_t;
typedef unary<ParserT, parser<self_t> > base_t;
typedef ActionT predicate_t;
template <typename ScannerT>
struct result
{
typedef typename parser_result<ParserT, ScannerT>::type type;
};
action(ParserT const& p, ActionT const& a) ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
ActionT const& predicate() const ;
private:
ActionT actor;
};
}
}}
namespace boost { namespace spirit {
namespace classic {
struct lexeme_parser_gen;
template <typename ParserT>
struct contiguous
: public unary<ParserT, parser<contiguous<ParserT> > >
{
typedef contiguous<ParserT> self_t;
typedef unary_parser_category parser_category_t;
typedef lexeme_parser_gen parser_generator_t;
typedef unary<ParserT, parser<self_t> > base_t;
template <typename ScannerT>
struct result
{
typedef typename parser_result<ParserT, ScannerT>::type type;
};
contiguous(ParserT const& p) ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
struct lexeme_parser_gen
{
template <typename ParserT>
struct result {
typedef contiguous<ParserT> type;
};
template <typename ParserT>
static contiguous<ParserT>
generate(parser<ParserT> const& subject)
;
template <typename ParserT>
contiguous<ParserT>
operator[](parser<ParserT> const& subject) const
;
};
const lexeme_parser_gen lexeme_d = lexeme_parser_gen();
template <typename ScannerT>
struct lexeme_scanner
{
typedef scanner_policies<
no_skipper_iteration_policy<
typename ScannerT::iteration_policy_t>,
typename ScannerT::match_policy_t,
typename ScannerT::action_policy_t
> policies_t;
typedef typename
rebind_scanner_policies<ScannerT, policies_t>::type type;
};
template <typename BaseT>
struct inhibit_case_iteration_policy : public BaseT
{
typedef BaseT base_t;
inhibit_case_iteration_policy() ;
template <typename PolicyT>
inhibit_case_iteration_policy(PolicyT const& other) ;
template <typename CharT>
CharT filter(CharT ch) const
;
};
struct inhibit_case_parser_gen;
template <typename ParserT>
struct inhibit_case
: public unary<ParserT, parser<inhibit_case<ParserT> > >
{
typedef inhibit_case<ParserT> self_t;
typedef unary_parser_category parser_category_t;
typedef inhibit_case_parser_gen parser_generator_t;
typedef unary<ParserT, parser<self_t> > base_t;
template <typename ScannerT>
struct result
{
typedef typename parser_result<ParserT, ScannerT>::type type;
};
inhibit_case(ParserT const& p) ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
template <int N>
struct inhibit_case_parser_gen_base
{
static inhibit_case<strlit<char const*> >
generate(char const* str)
;
static inhibit_case<strlit<wchar_t const*> >
generate(wchar_t const* str)
;
static inhibit_case<chlit<char> >
generate(char ch)
;
static inhibit_case<chlit<wchar_t> >
generate(wchar_t ch)
;
template <typename ParserT>
static inhibit_case<ParserT>
generate(parser<ParserT> const& subject)
;
inhibit_case<strlit<char const*> >
operator[](char const* str) const
;
inhibit_case<strlit<wchar_t const*> >
operator[](wchar_t const* str) const
;
inhibit_case<chlit<char> >
operator[](char ch) const
;
inhibit_case<chlit<wchar_t> >
operator[](wchar_t ch) const
;
template <typename ParserT>
inhibit_case<ParserT>
operator[](parser<ParserT> const& subject) const
;
};
struct inhibit_case_parser_gen : public inhibit_case_parser_gen_base<0>
{
inhibit_case_parser_gen() ;
};
const inhibit_case_parser_gen nocase_d = inhibit_case_parser_gen();
const inhibit_case_parser_gen as_lower_d = inhibit_case_parser_gen();
template <typename ScannerT>
struct as_lower_scanner
{
typedef scanner_policies<
inhibit_case_iteration_policy<
typename ScannerT::iteration_policy_t>,
typename ScannerT::match_policy_t,
typename ScannerT::action_policy_t
> policies_t;
typedef typename
rebind_scanner_policies<ScannerT, policies_t>::type type;
};
struct longest_parser_gen;
template <typename A, typename B>
struct longest_alternative
: public binary<A, B, parser<longest_alternative<A, B> > >
{
typedef longest_alternative<A, B> self_t;
typedef binary_parser_category parser_category_t;
typedef longest_parser_gen parser_generator_t;
typedef binary<A, B, parser<self_t> > base_t;
longest_alternative(A const& a, B const& b) ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
struct longest_parser_gen
{
template <typename A, typename B>
struct result {
typedef typename
impl::to_longest_alternative<alternative<A, B> >::result_t
type;
};
template <typename A, typename B>
static typename
impl::to_longest_alternative<alternative<A, B> >::result_t
generate(alternative<A, B> const& alt)
;
template <typename A, typename B>
static
longest_alternative<A, B>
generate(A const &left, B const &right)
;
template <typename A, typename B>
typename impl::to_longest_alternative<alternative<A, B> >::result_t
operator[](alternative<A, B> const& alt) const
;
};
const longest_parser_gen longest_d = longest_parser_gen();
struct shortest_parser_gen;
template <typename A, typename B>
struct shortest_alternative
: public binary<A, B, parser<shortest_alternative<A, B> > >
{
typedef shortest_alternative<A, B> self_t;
typedef binary_parser_category parser_category_t;
typedef shortest_parser_gen parser_generator_t;
typedef binary<A, B, parser<self_t> > base_t;
shortest_alternative(A const& a, B const& b) ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
struct shortest_parser_gen
{
template <typename A, typename B>
struct result {
typedef typename
impl::to_shortest_alternative<alternative<A, B> >::result_t
type;
};
template <typename A, typename B>
static typename
impl::to_shortest_alternative<alternative<A, B> >::result_t
generate(alternative<A, B> const& alt)
;
template <typename A, typename B>
static
shortest_alternative<A, B>
generate(A const &left, B const &right)
;
template <typename A, typename B>
typename impl::to_shortest_alternative<alternative<A, B> >::result_t
operator[](alternative<A, B> const& alt) const
;
};
const shortest_parser_gen shortest_d = shortest_parser_gen();
template <typename BoundsT>
struct min_bounded_gen;
template <typename ParserT, typename BoundsT>
struct min_bounded
: public unary<ParserT, parser<min_bounded<ParserT, BoundsT> > >
{
typedef min_bounded<ParserT, BoundsT> self_t;
typedef unary_parser_category parser_category_t;
typedef min_bounded_gen<BoundsT> parser_generator_t;
typedef unary<ParserT, parser<self_t> > base_t;
template <typename ScannerT>
struct result
{
typedef typename parser_result<ParserT, ScannerT>::type type;
};
min_bounded(ParserT const& p, BoundsT const& min__) ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
BoundsT min_;
};
template <typename BoundsT>
struct min_bounded_gen
{
min_bounded_gen(BoundsT const& min__) ;
template <typename DerivedT>
min_bounded<DerivedT, BoundsT>
operator[](parser<DerivedT> const& p) const
;
BoundsT min_;
};
template <typename BoundsT>
min_bounded_gen<BoundsT>
min_limit_d(BoundsT const& min_)
;
template <typename BoundsT>
struct max_bounded_gen;
template <typename ParserT, typename BoundsT>
struct max_bounded
: public unary<ParserT, parser<max_bounded<ParserT, BoundsT> > >
{
typedef max_bounded<ParserT, BoundsT> self_t;
typedef unary_parser_category parser_category_t;
typedef max_bounded_gen<BoundsT> parser_generator_t;
typedef unary<ParserT, parser<self_t> > base_t;
template <typename ScannerT>
struct result
{
typedef typename parser_result<ParserT, ScannerT>::type type;
};
max_bounded(ParserT const& p, BoundsT const& max__) ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
BoundsT max_;
};
template <typename BoundsT>
struct max_bounded_gen
{
max_bounded_gen(BoundsT const& max__) ;
template <typename DerivedT>
max_bounded<DerivedT, BoundsT>
operator[](parser<DerivedT> const& p) const
;
BoundsT max_;
};
template <typename BoundsT>
max_bounded_gen<BoundsT>
max_limit_d(BoundsT const& max_)
;
template <typename BoundsT>
struct bounded_gen;
template <typename ParserT, typename BoundsT>
struct bounded
: public unary<ParserT, parser<bounded<ParserT, BoundsT> > >
{
typedef bounded<ParserT, BoundsT> self_t;
typedef unary_parser_category parser_category_t;
typedef bounded_gen<BoundsT> parser_generator_t;
typedef unary<ParserT, parser<self_t> > base_t;
template <typename ScannerT>
struct result
{
typedef typename parser_result<ParserT, ScannerT>::type type;
};
bounded(ParserT const& p, BoundsT const& min__, BoundsT const& max__) ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
BoundsT min_, max_;
};
template <typename BoundsT>
struct bounded_gen
{
bounded_gen(BoundsT const& min__, BoundsT const& max__) ;
template <typename DerivedT>
bounded<DerivedT, BoundsT>
operator[](parser<DerivedT> const& p) const
;
BoundsT min_, max_;
};
template <typename BoundsT>
bounded_gen<BoundsT>
limit_d(BoundsT const& min_, BoundsT const& max_)
;
}
}}
namespace boost { namespace spirit {
namespace classic {
template <
typename T = unsigned,
int Radix = 10,
unsigned MinDigits = 1,
int MaxDigits = -1
>
struct uint_parser;
template <
typename T = unsigned,
int Radix = 10,
unsigned MinDigits = 1,
int MaxDigits = -1
>
struct int_parser;
struct sign_parser;
template <typename T>
struct ureal_parser_policies;
template <typename T>
struct real_parser_policies;
template <
typename T = double,
typename RealPoliciesT = ureal_parser_policies<T>
>
struct real_parser;
template <typename T>
struct strict_ureal_parser_policies;
template <typename T>
struct strict_real_parser_policies;
}
}}
extern "C" {
typedef float float_t;
typedef double double_t;
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 ();
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 ();
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 ();
extern int signgam;
enum
{
FP_NAN =
0,
FP_INFINITE =
1,
FP_ZERO =
2,
FP_SUBNORMAL =
3,
FP_NORMAL =
4
};
typedef enum
{
_IEEE_ = -1,
_SVID_,
_XOPEN_,
_POSIX_,
_ISOC_
} _LIB_VERSION_TYPE;
extern _LIB_VERSION_TYPE _LIB_VERSION;
struct __exception
{
int type;
char *name;
double arg1;
double arg2;
double retval;
};
extern int matherr (struct __exception *__exc) throw ();
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) __signbitf (float __x) throw ()
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) __signbit (double __x) throw ()
;
extern __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) __signbitl (long double __x) throw ()
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
double
abs(double __x)
;
float
abs(float __x)
;
long double
abs(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
abs(_Tp __x)
;
using ::acos;
float
acos(float __x)
;
long double
acos(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
acos(_Tp __x)
;
using ::asin;
float
asin(float __x)
;
long double
asin(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
asin(_Tp __x)
;
using ::atan;
float
atan(float __x)
;
long double
atan(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
atan(_Tp __x)
;
using ::atan2;
float
atan2(float __y, float __x)
;
long double
atan2(long double __y, long double __x)
;
template<typename _Tp, typename _Up>
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
atan2(_Tp __y, _Up __x)
;
using ::ceil;
float
ceil(float __x)
;
long double
ceil(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
ceil(_Tp __x)
;
using ::cos;
float
cos(float __x)
;
long double
cos(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cos(_Tp __x)
;
using ::cosh;
float
cosh(float __x)
;
long double
cosh(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cosh(_Tp __x)
;
using ::exp;
float
exp(float __x)
;
long double
exp(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
exp(_Tp __x)
;
using ::fabs;
float
fabs(float __x)
;
long double
fabs(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
fabs(_Tp __x)
;
using ::floor;
float
floor(float __x)
;
long double
floor(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
floor(_Tp __x)
;
using ::fmod;
float
fmod(float __x, float __y)
;
long double
fmod(long double __x, long double __y)
;
template<typename _Tp, typename _Up>
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fmod(_Tp __x, _Up __y)
;
using ::frexp;
float
frexp(float __x, int* __exp)
;
long double
frexp(long double __x, int* __exp)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
frexp(_Tp __x, int* __exp)
;
using ::ldexp;
float
ldexp(float __x, int __exp)
;
long double
ldexp(long double __x, int __exp)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
ldexp(_Tp __x, int __exp)
;
using ::log;
float
log(float __x)
;
long double
log(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log(_Tp __x)
;
using ::log10;
float
log10(float __x)
;
long double
log10(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log10(_Tp __x)
;
using ::modf;
float
modf(float __x, float* __iptr)
;
long double
modf(long double __x, long double* __iptr)
;
using ::pow;
float
pow(float __x, float __y)
;
long double
pow(long double __x, long double __y)
;
double
pow(double __x, int __i)
;
float
pow(float __x, int __n)
;
long double
pow(long double __x, int __n)
;
template<typename _Tp, typename _Up>
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
pow(_Tp __x, _Up __y)
;
using ::sin;
float
sin(float __x)
;
long double
sin(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sin(_Tp __x)
;
using ::sinh;
float
sinh(float __x)
;
long double
sinh(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sinh(_Tp __x)
;
using ::sqrt;
float
sqrt(float __x)
;
long double
sqrt(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sqrt(_Tp __x)
;
using ::tan;
float
tan(float __x)
;
long double
tan(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tan(_Tp __x)
;
using ::tanh;
float
tanh(float __x)
;
long double
tanh(long double __x)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tanh(_Tp __x)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
fpclassify(_Tp __f)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isfinite(_Tp __f)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isinf(_Tp __f)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isnan(_Tp __f)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isnormal(_Tp __f)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
signbit(_Tp __f)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isgreater(_Tp __f1, _Tp __f2)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isgreaterequal(_Tp __f1, _Tp __f2)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isless(_Tp __f1, _Tp __f2)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
islessequal(_Tp __f1, _Tp __f2)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
islessgreater(_Tp __f1, _Tp __f2)
;
template<typename _Tp>
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isunordered(_Tp __f1, _Tp __f2)
;
}
namespace boost { namespace spirit {
namespace classic {
struct sign_parser;
namespace impl
{
template <typename ScannerT>
bool
extract_sign(ScannerT const& scan, std::size_t& count)
;
template<const int Radix>
struct radix_traits;
template<>
struct radix_traits<2>
{
template<typename CharT, typename T>
static bool digit(CharT ch, T& val)
;
};
template<>
struct radix_traits<8>
{
template<typename CharT, typename T>
static bool digit(CharT ch, T& val)
;
};
template<>
struct radix_traits<10>
{
template<typename CharT, typename T>
static bool digit(CharT ch, T& val)
;
};
template<>
struct radix_traits<16>
{
template<typename CharT, typename T>
static bool digit(CharT ch, T& val)
;
};
template <typename T, int Radix>
struct positive_accumulate
{
static bool add(T& n, T digit)
;
};
template <typename T, int Radix>
struct negative_accumulate
{
static bool add(T& n, T digit)
;
};
template <int MaxDigits>
bool allow_more_digits(std::size_t i)
;
template <>
bool allow_more_digits<-1>(std::size_t)
;
template <
int Radix, unsigned MinDigits, int MaxDigits,
typename Accumulate
>
struct extract_int
{
template <typename ScannerT, typename T>
static bool
f(ScannerT& scan, T& n, std::size_t& count)
;
};
template <
typename T = unsigned,
int Radix = 10,
unsigned MinDigits = 1,
int MaxDigits = -1
>
struct uint_parser_impl
: parser<uint_parser_impl<T, Radix, MinDigits, MaxDigits> >
{
typedef uint_parser_impl<T, Radix, MinDigits, MaxDigits> self_t;
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, T>::type type;
};
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
template <
typename T = unsigned,
int Radix = 10,
unsigned MinDigits = 1,
int MaxDigits = -1
>
struct int_parser_impl
: parser<int_parser_impl<T, Radix, MinDigits, MaxDigits> >
{
typedef int_parser_impl<T, Radix, MinDigits, MaxDigits> self_t;
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, T>::type type;
};
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
template <typename RT, typename T, typename RealPoliciesT>
struct real_parser_impl
{
typedef real_parser_impl<RT, T, RealPoliciesT> self_t;
template <typename ScannerT>
RT parse_main(ScannerT const& scan) const
;
template <typename ScannerT>
static RT parse(ScannerT const& scan)
;
};
}
}
}}
namespace boost { namespace spirit {
namespace classic {
template <
typename T,
int Radix,
unsigned MinDigits,
int MaxDigits
>
struct uint_parser : parser<uint_parser<T, Radix, MinDigits, MaxDigits> >
{
typedef uint_parser<T, Radix, MinDigits, MaxDigits> self_t;
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, T>::type type;
};
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
template <
typename T,
int Radix,
unsigned MinDigits,
int MaxDigits
>
struct int_parser : parser<int_parser<T, Radix, MinDigits, MaxDigits> >
{
typedef int_parser<T, Radix, MinDigits, MaxDigits> self_t;
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, T>::type type;
};
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
int_parser<int> const
int_p = int_parser<int>();
uint_parser<unsigned> const
uint_p = uint_parser<unsigned>();
uint_parser<unsigned, 2> const
bin_p = uint_parser<unsigned, 2>();
uint_parser<unsigned, 8> const
oct_p = uint_parser<unsigned, 8>();
uint_parser<unsigned, 16> const
hex_p = uint_parser<unsigned, 16>();
namespace impl
{
template <typename ScannerT>
bool extract_sign(ScannerT const& scan, std::size_t& count);
}
struct sign_parser : public parser<sign_parser>
{
typedef sign_parser self_t;
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, bool>::type type;
};
sign_parser() ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
sign_parser const sign_p = sign_parser();
template <typename T>
struct ureal_parser_policies
{
static const
bool allow_leading_dot = true;
static const
bool allow_trailing_dot = true;
static const
bool expect_dot = false;
typedef uint_parser<T, 10, 1, -1> uint_parser_t;
typedef int_parser<T, 10, 1, -1> int_parser_t;
template <typename ScannerT>
static typename match_result<ScannerT, nil_t>::type
parse_sign(ScannerT& scan)
;
template <typename ScannerT>
static typename parser_result<uint_parser_t, ScannerT>::type
parse_n(ScannerT& scan)
;
template <typename ScannerT>
static typename parser_result<chlit<>, ScannerT>::type
parse_dot(ScannerT& scan)
;
template <typename ScannerT>
static typename parser_result<uint_parser_t, ScannerT>::type
parse_frac_n(ScannerT& scan)
;
template <typename ScannerT>
static typename parser_result<chlit<>, ScannerT>::type
parse_exp(ScannerT& scan)
;
template <typename ScannerT>
static typename parser_result<int_parser_t, ScannerT>::type
parse_exp_n(ScannerT& scan)
;
};
template <typename T>
struct real_parser_policies : public ureal_parser_policies<T>
{
template <typename ScannerT>
static typename parser_result<sign_parser, ScannerT>::type
parse_sign(ScannerT& scan)
;
};
template <
typename T,
typename RealPoliciesT
>
struct real_parser
: public parser<real_parser<T, RealPoliciesT> >
{
typedef real_parser<T, RealPoliciesT> self_t;
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, T>::type type;
};
real_parser() ;
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
;
};
real_parser<double, ureal_parser_policies<double> > const
ureal_p = real_parser<double, ureal_parser_policies<double> >();
real_parser<double, real_parser_policies<double> > const
real_p = real_parser<double, real_parser_policies<double> >();
template <typename T>
struct strict_ureal_parser_policies : public ureal_parser_policies<T>
{
static const
bool expect_dot = true;
};
template <typename T>
struct strict_real_parser_policies : public real_parser_policies<T>
{
static const
bool expect_dot = true;
};
real_parser<double, strict_ureal_parser_policies<double> > const
strict_ureal_p
= real_parser<double, strict_ureal_parser_policies<double> >();
real_parser<double, strict_real_parser_policies<double> > const
strict_real_p
= real_parser<double, strict_real_parser_policies<double> >();
}
}}
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;
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 >;
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;
typedef boost::uintmax_t static_gcd_type;
template < static_gcd_type Value1, static_gcd_type Value2 >
struct static_gcd;
template < static_gcd_type Value1, static_gcd_type Value2 >
struct static_lcm;
template < typename IntegerType >
class gcd_evaluator;
template < typename IntegerType >
class lcm_evaluator;
}
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; };
}
template< int Bits >
struct int_t : public boost::detail::exact_signed_base_helper<Bits>
{
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((Bits <= (int)(sizeof(boost::intmax_t) * 8)) == 0 ? false : true) >)> boost_static_assert_typedef_118 __attribute__((unused))
;
typedef typename boost::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 boost::detail::exact_unsigned_base_helper<Bits>
{
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((Bits <= (int)(sizeof(boost::uintmax_t) * 8)) == 0 ? false : true) >)> boost_static_assert_typedef_139 __attribute__((unused))
;
typedef typename boost::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 boost::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 boost::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
{
typedef typename boost::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;
};
}
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: };
}
namespace boost {
namespace detail {
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: };
}
namespace boost {
template<typename F, typename G>
bool function_equal_impl(const F& f, const G& g, long)
;
template<typename F, typename G>
bool function_equal(const F& f, const G& g)
;
}
namespace boost {
class bad_function_call;
template<typename Signature> class function;
template<typename Signature>
void swap(function<Signature>& f1, function<Signature>& 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;
}
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 void
manage(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op)
;
};
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 )
;
functor_wrapper(const functor_wrapper& f)
;
};
template<typename Functor>
struct functor_manager_common
{
typedef Functor functor_type;
static void
manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op)
;
static void
manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op)
;
};
template<typename Functor>
struct functor_manager
{
private:
typedef Functor functor_type;
static void
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, function_ptr_tag)
;
static void
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, mpl::true_)
;
static void
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, mpl::false_)
;
static void
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, function_obj_tag)
;
static void
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, member_ptr_tag)
;
public:
static void
manage(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op)
;
};
template<typename Functor, typename Allocator>
struct functor_manager_a
{
private:
typedef Functor functor_type;
static void
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, function_ptr_tag)
;
static void
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, mpl::true_)
;
static void
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, mpl::false_)
;
static void
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, function_obj_tag)
;
public:
static void
manage(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op)
;
};
struct useless_clear_type {};
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() ;
bool empty() const ;
const detail::sp_typeinfo& target_type() const
;
template<typename Functor>
Functor* target()
;
template<typename Functor>
const Functor* target() const
;
template<typename F>
bool contains(const F& f) const
;
public:
detail::function::vtable_base* get_vtable() const ;
bool has_trivial_copy_and_destroy() const ;
detail::function::vtable_base* vtable;
mutable detail::function::function_buffer functor;
};
class bad_function_call : public std::runtime_error
{
public:
bad_function_call() ;
};
bool operator==(const function_base& f,
detail::function::useless_clear_type*)
;
bool operator!=(const function_base& f,
detail::function::useless_clear_type*)
;
bool operator==(detail::function::useless_clear_type*,
const function_base& f)
;
bool operator!=(detail::function::useless_clear_type*,
const function_base& f)
;
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)
;
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)
;
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)
;
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)
;
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)
;
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)
;
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)
;
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)
;
namespace detail {
namespace function {
bool has_empty_target(const function_base* f)
;
bool has_empty_target(...)
;
}
}
}
namespace boost {
template<class T> T * get_pointer(T * p)
;
template<class T> T * get_pointer(std::auto_ptr<T> const& p)
;
}
namespace boost
{
namespace _mfi
{
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
;
template<class U> R call(U & u, void const *) const
;
public:
explicit mf0(F f) ;
R operator()(T * p) const
;
template<class U> R operator()(U & u) const
;
template<class U> R operator()(U const & u) const
;
R operator()(T & t) const
;
bool operator==(mf0 const & rhs) const
;
bool operator!=(mf0 const & rhs) const
;
};
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
;
template<class U> R call(U & u, void const *) const
;
public:
explicit cmf0(F f) ;
template<class U> R operator()(U const & u) const
;
R operator()(T const & t) const
;
bool operator==(cmf0 const & rhs) const
;
bool operator!=(cmf0 const & rhs) const
;
};
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
;
template<class U, class B1> R call(U & u, void const *, B1 & b1) const
;
public:
explicit mf1(F f) ;
R operator()(T * p, A1 a1) const
;
template<class U> R operator()(U & u, A1 a1) const
;
template<class U> R operator()(U const & u, A1 a1) const
;
R operator()(T & t, A1 a1) const
;
bool operator==(mf1 const & rhs) const
;
bool operator!=(mf1 const & rhs) const
;
};
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
;
template<class U, class B1> R call(U & u, void const *, B1 & b1) const
;
public:
explicit cmf1(F f) ;
template<class U> R operator()(U const & u, A1 a1) const
;
R operator()(T const & t, A1 a1) const
;
bool operator==(cmf1 const & rhs) const
;
bool operator!=(cmf1 const & rhs) const
;
};
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
;
template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
;
public:
explicit mf2(F f) ;
R operator()(T * p, A1 a1, A2 a2) const
;
template<class U> R operator()(U & u, A1 a1, A2 a2) const
;
template<class U> R operator()(U const & u, A1 a1, A2 a2) const
;
R operator()(T & t, A1 a1, A2 a2) const
;
bool operator==(mf2 const & rhs) const
;
bool operator!=(mf2 const & rhs) const
;
};
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
;
template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
;
public:
explicit cmf2(F f) ;
template<class U> R operator()(U const & u, A1 a1, A2 a2) const
;
R operator()(T const & t, A1 a1, A2 a2) const
;
bool operator==(cmf2 const & rhs) const
;
bool operator!=(cmf2 const & rhs) const
;
};
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
;
template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
;
public:
explicit mf3(F f) ;
R operator()(T * p, A1 a1, A2 a2, A3 a3) const
;
template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
;
template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
;
R operator()(T & t, A1 a1, A2 a2, A3 a3) const
;
bool operator==(mf3 const & rhs) const
;
bool operator!=(mf3 const & rhs) const
;
};
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
;
template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
;
public:
explicit cmf3(F f) ;
template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
;
R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
;
bool operator==(cmf3 const & rhs) const
;
bool operator!=(cmf3 const & rhs) const
;
};
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
;
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
;
public:
explicit mf4(F f) ;
R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
;
template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
;
template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
;
R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
;
bool operator==(mf4 const & rhs) const
;
bool operator!=(mf4 const & rhs) const
;
};
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
;
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
;
public:
explicit cmf4(F f) ;
template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
;
R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
;
bool operator==(cmf4 const & rhs) const
;
bool operator!=(cmf4 const & rhs) const
;
};
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
;
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
;
public:
explicit mf5(F f) ;
R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
;
template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
;
template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
;
R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
;
bool operator==(mf5 const & rhs) const
;
bool operator!=(mf5 const & rhs) const
;
};
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
;
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
;
public:
explicit cmf5(F f) ;
template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
;
R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
;
bool operator==(cmf5 const & rhs) const
;
bool operator!=(cmf5 const & rhs) const
;
};
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
;
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
;
public:
explicit mf6(F f) ;
R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
;
template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
;
template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
;
R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
;
bool operator==(mf6 const & rhs) const
;
bool operator!=(mf6 const & rhs) const
;
};
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
;
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
;
public:
explicit cmf6(F f) ;
template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
;
R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
;
bool operator==(cmf6 const & rhs) const
;
bool operator!=(cmf6 const & rhs) const
;
};
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
;
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
;
public:
explicit mf7(F f) ;
R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
;
template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
;
template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
;
R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
;
bool operator==(mf7 const & rhs) const
;
bool operator!=(mf7 const & rhs) const
;
};
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
;
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
;
public:
explicit cmf7(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
;
R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
;
bool operator==(cmf7 const & rhs) const
;
bool operator!=(cmf7 const & rhs) const
;
};
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
;
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
;
public:
explicit mf8(F f) ;
R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
;
template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
;
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
;
R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
;
bool operator==(mf8 const & rhs) const
;
bool operator!=(mf8 const & rhs) const
;
};
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
;
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
;
public:
explicit cmf8(F f) ;
R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
;
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
;
R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
;
bool operator==(cmf8 const & rhs) const
;
bool operator!=(cmf8 const & rhs) const
;
};
}
template<class R, class T> _mfi::mf0<R, T> mem_fn(R ( T::*f) ())
;
template<class R, class T> _mfi::cmf0<R, T> mem_fn(R ( T::*f) () const)
;
template<class R, class T, class A1> _mfi::mf1<R, T, A1> mem_fn(R ( T::*f) (A1))
;
template<class R, class T, class A1> _mfi::cmf1<R, T, A1> mem_fn(R ( T::*f) (A1) const)
;
template<class R, class T, class A1, class A2> _mfi::mf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2))
;
template<class R, class T, class A1, class A2> _mfi::cmf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2) const)
;
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))
;
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)
;
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))
;
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)
;
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))
;
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)
;
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))
;
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)
;
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))
;
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)
;
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))
;
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)
;
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
;
template<class U> R const & call(U & u, void const *) const
;
public:
explicit dm(F f) ;
R & operator()(T * p) const
;
R const & operator()(T const * p) const
;
template<class U> R const & operator()(U const & u) const
;
R & operator()(T & t) const
;
R const & operator()(T const & t) const
;
bool operator==(dm const & rhs) const
;
bool operator!=(dm const & rhs) const
;
};
}
template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f)
;
}
namespace boost {
namespace detail {
namespace function {
template<
typename FunctionPtr,
typename R
>
struct function_invoker0
{
static R invoke(function_buffer& function_ptr
)
;
};
template<
typename FunctionPtr,
typename R
>
struct void_function_invoker0
{
static void
invoke(function_buffer& function_ptr
)
;
};
template<
typename FunctionObj,
typename R
>
struct function_obj_invoker0
{
static R invoke(function_buffer& function_obj_ptr
)
;
};
template<
typename FunctionObj,
typename R
>
struct void_function_obj_invoker0
{
static void
invoke(function_buffer& function_obj_ptr
)
;
};
template<
typename FunctionObj,
typename R
>
struct function_ref_invoker0
{
static R invoke(function_buffer& function_obj_ptr
)
;
};
template<
typename FunctionObj,
typename R
>
struct void_function_ref_invoker0
{
static void
invoke(function_buffer& function_obj_ptr
)
;
};
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;
};
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;
};
};
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;
};
};
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
;
template<typename F,typename Allocator>
bool assign_to_a(F f, function_buffer& functor, Allocator a) const
;
void clear(function_buffer& functor) const
;
private:
template<typename FunctionPtr>
bool
assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
;
template<typename FunctionPtr,typename Allocator>
bool
assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
;
template<typename FunctionObj>
void
assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
;
template<typename FunctionObj,typename Allocator>
void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
;
template<typename FunctionObj>
void
assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
;
template<typename FunctionObj,typename Allocator>
void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
;
template<typename FunctionObj>
bool
assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
;
template<typename FunctionObj,typename Allocator>
bool
assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
;
template<typename FunctionObj>
bool
assign_to(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, function_obj_ref_tag) const
;
template<typename FunctionObj,typename Allocator>
bool
assign_to_a(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, Allocator, function_obj_ref_tag) const
;
public:
vtable_base base;
invoker_type invoker;
};
}
}
template<
typename R
>
class function0 : public function_base
{
public:
typedef R result_type;
private:
typedef boost::detail::function::basic_vtable0<
R >
vtable_type;
vtable_type* get_vtable() const ;
struct clear_type {};
public:
static const
int args = 0;
template<typename Args>
struct sig
{
typedef result_type type;
};
static const
int arity = 0;
typedef function0 self_type;
function0() ;
template<typename Functor>
function0(Functor f
,typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
int>::type = 0
)
;
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
)
;
function0(clear_type*) ;
function0(const function0& f)
;
~function0() ;
result_type operator()() const
;
template<typename Functor>
typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
function0&>::type
operator=(Functor f)
;
template<typename Functor,typename Allocator>
void assign(Functor f, Allocator a)
;
function0& operator=(clear_type*)
;
function0& operator=(const function0& f)
;
void swap(function0& other)
;
void clear()
;
private:
struct dummy {
void nonnull() ;
};
typedef void (dummy::*safe_bool)();
public:
operator safe_bool () const
;
bool operator!() const
;
private:
void assign_to_own(const function0& f)
;
template<typename Functor>
void assign_to(Functor f)
;
template<typename Functor,typename Allocator>
void assign_to_a(Functor f,Allocator a)
;
void move_assign(function0& f)
;
};
template<typename R >
void swap(function0<
R
>& f1,
function0<
R
>& f2)
;
template<typename R >
void operator==(const function0<
R
>&,
const function0<
R
>&);
template<typename R >
void operator!=(const function0<
R
>&,
const function0<
R
>& );
template<typename R
>
class function<R (void)>
: public function0<R >
{
typedef function0<R > base_type;
typedef function self_type;
struct clear_type {};
public:
function() ;
template<typename Functor>
function(Functor f
,typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
int>::type = 0
)
;
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
)
;
function(clear_type*) ;
function(const self_type& f) ;
function(const base_type& f) ;
self_type& operator=(const self_type& f)
;
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& operator=(clear_type*)
;
self_type& operator=(const base_type& f)
;
};
}
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)
;
};
template<
typename FunctionPtr,
typename R ,
typename T0
>
struct void_function_invoker1
{
static void
invoke(function_buffer& function_ptr ,
T0 a0)
;
};
template<
typename FunctionObj,
typename R ,
typename T0
>
struct function_obj_invoker1
{
static R invoke(function_buffer& function_obj_ptr ,
T0 a0)
;
};
template<
typename FunctionObj,
typename R ,
typename T0
>
struct void_function_obj_invoker1
{
static void
invoke(function_buffer& function_obj_ptr ,
T0 a0)
;
};
template<
typename FunctionObj,
typename R ,
typename T0
>
struct function_ref_invoker1
{
static R invoke(function_buffer& function_obj_ptr ,
T0 a0)
;
};
template<
typename FunctionObj,
typename R ,
typename T0
>
struct void_function_ref_invoker1
{
static void
invoke(function_buffer& function_obj_ptr ,
T0 a0)
;
};
template<
typename MemberPtr,
typename R ,
typename T0
>
struct function_mem_invoker1
{
static R invoke(function_buffer& function_obj_ptr ,
T0 a0)
;
};
template<
typename MemberPtr,
typename R ,
typename T0
>
struct function_void_mem_invoker1
{
static void
invoke(function_buffer& function_obj_ptr ,
T0 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;
};
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;
};
};
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
;
template<typename F,typename Allocator>
bool assign_to_a(F f, function_buffer& functor, Allocator a) const
;
void clear(function_buffer& functor) const
;
private:
template<typename FunctionPtr>
bool
assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
;
template<typename FunctionPtr,typename Allocator>
bool
assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
;
template<typename MemberPtr>
bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
;
template<typename MemberPtr,typename Allocator>
bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
;
template<typename FunctionObj>
void
assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
;
template<typename FunctionObj,typename Allocator>
void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
;
template<typename FunctionObj>
void
assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
;
template<typename FunctionObj,typename Allocator>
void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
;
template<typename FunctionObj>
bool
assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
;
template<typename FunctionObj,typename Allocator>
bool
assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
;
template<typename FunctionObj>
bool
assign_to(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, function_obj_ref_tag) const
;
template<typename FunctionObj,typename Allocator>
bool
assign_to_a(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, Allocator, function_obj_ref_tag) const
;
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 ;
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() ;
template<typename Functor>
function1(Functor f
,typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
int>::type = 0
)
;
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
)
;
function1(clear_type*) ;
function1(const function1& f)
;
~function1() ;
result_type operator()( T0 a0) const
;
template<typename Functor>
typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
function1&>::type
operator=(Functor f)
;
template<typename Functor,typename Allocator>
void assign(Functor f, Allocator a)
;
function1& operator=(clear_type*)
;
function1& operator=(const function1& f)
;
void swap(function1& other)
;
void clear()
;
private:
struct dummy {
void nonnull() ;
};
typedef void (dummy::*safe_bool)();
public:
operator safe_bool () const
;
bool operator!() const
;
private:
void assign_to_own(const function1& f)
;
template<typename Functor>
void assign_to(Functor f)
;
template<typename Functor,typename Allocator>
void assign_to_a(Functor f,Allocator a)
{
using boost::detail::function::vtable_base;
typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
typedef boost::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 &&
boost::detail::function::function_allows_small_object_optimization<Functor>::value)
value |= static_cast<std::size_t>(0x01);
vtable = reinterpret_cast<boost::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>& );
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)){}
self_type& operator=(const self_type& f)
{
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;
}
};
}
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;
};
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;
};
};
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() { 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;
}
function2& operator=(const function2& f)
{
if (&f == this)
return *this;
this->clear();
{ try {
this->assign_to_own(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 boost::detail::function::vtable_base;
typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
typedef boost::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 &&
boost::detail::function::function_allows_small_object_optimization<Functor>::value)
value |= static_cast<std::size_t>(0x01);
vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
} else
vtable = 0;
}
template<typename Functor,typename Allocator>
void assign_to_a(Functor f,Allocator a)
{
using boost::detail::function::vtable_base;
typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
typedef boost::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 &&
boost::detail::function::function_allows_small_object_optimization<Functor>::value)
value |= static_cast<std::size_t>(0x01);
vtable = reinterpret_cast<boost::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>& );
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)){}
self_type& operator=(const self_type& f)
{
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;
}
};
}
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;
};
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;
};
};
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
{
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;
};
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() { 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;
}
function3& operator=(const function3& f)
{
if (&f == this)
return *this;
this->clear();
{ try {
this->assign_to_own(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 boost::detail::function::vtable_base;
typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
typedef boost::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 &&
boost::detail::function::function_allows_small_object_optimization<Functor>::value)
value |= static_cast<std::size_t>(0x01);
vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
} else
vtable = 0;
}
template<typename Functor,typename Allocator>
void assign_to_a(Functor f,Allocator a)
{
using boost::detail::function::vtable_base;
typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
typedef boost::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 &&
boost::detail::function::function_allows_small_object_optimization<Functor>::value)
value |= static_cast<std::size_t>(0x01);
vtable = reinterpret_cast<boost::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>& );
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)){}
self_type& operator=(const self_type& f)
{
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;
}
};
}
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;
};
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;
};
};
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
{
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;
};
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() { 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;
}
function4& operator=(const function4& f)
{
if (&f == this)
return *this;
this->clear();
{ try {
this->assign_to_own(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 boost::detail::function::vtable_base;
typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
typedef boost::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 &&
boost::detail::function::function_allows_small_object_optimization<Functor>::value)
value |= static_cast<std::size_t>(0x01);
vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
} else
vtable = 0;
}
template<typename Functor,typename Allocator>
void assign_to_a(Functor f,Allocator a)
{
using boost::detail::function::vtable_base;
typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
typedef boost::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 &&
boost::detail::function::function_allows_small_object_optimization<Functor>::value)
value |= static_cast<std::size_t>(0x01);
vtable = reinterpret_cast<boost::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>& );
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)){}
self_type& operator=(const self_type& f)
{
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;
}
};
}
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;
};
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;
};
};
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
{
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;
};
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() { 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;
}
function5& operator=(const function5& f)
{
if (&f == this)
return *this;
this->clear();
{ try {
this->assign_to_own(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 boost::detail::function::vtable_base;
typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
typedef boost::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 &&
boost::detail::function::function_allows_small_object_optimization<Functor>::value)
value |= static_cast<std::size_t>(0x01);
vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
} else
vtable = 0;
}
template<typename Functor,typename Allocator>
void assign_to_a(Functor f,Allocator a)
{
using boost::detail::function::vtable_base;
typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
typedef boost::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 &&
boost::detail::function::function_allows_small_object_optimization<Functor>::value)
value |= static_cast<std::size_t>(0x01);
vtable = reinterpret_cast<boost::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>& );
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)){}
self_type& operator=(const self_type& f)
{
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;
}
};
}
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;
};
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;
};
};
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
{
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;
};
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*) ;
function6(const function6& f)
;
~function6() ;
result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5) const
;
template<typename Functor>
typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
function6&>::type
operator=(Functor f)
;
template<typename Functor,typename Allocator>
void assign(Functor f, Allocator a)
;
function6& operator=(clear_type*)
;
function6& operator=(const function6& f)
;
void swap(function6& other)
;
void clear()
;
private:
struct dummy {
void nonnull() ;
};
typedef void (dummy::*safe_bool)();
public:
operator safe_bool () const
;
bool operator!() const
;
private:
void assign_to_own(const function6& f)
;
template<typename Functor>
void assign_to(Functor f)
;
template<typename Functor,typename Allocator>
void assign_to_a(Functor f,Allocator a)
;
void move_assign(function6& f)
;
};
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
void swap(function6<
R ,
T0 , T1 , T2 , T3 , T4 , T5
>& f1,
function6<
R ,
T0 , T1 , T2 , T3 , T4 , T5
>& 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>& );
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() ;
template<typename Functor>
function(Functor f
,typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
int>::type = 0
)
;
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
)
;
function(clear_type*) ;
function(const self_type& f) ;
function(const base_type& f) ;
self_type& operator=(const self_type& f)
;
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& operator=(clear_type*)
;
self_type& operator=(const base_type& f)
;
};
}
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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;
};
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;
};
};
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
;
template<typename F,typename Allocator>
bool assign_to_a(F f, function_buffer& functor, Allocator a) const
;
void clear(function_buffer& functor) const
;
private:
template<typename FunctionPtr>
bool
assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
;
template<typename FunctionPtr,typename Allocator>
bool
assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
;
template<typename MemberPtr>
bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
;
template<typename MemberPtr,typename Allocator>
bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
;
template<typename FunctionObj>
void
assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
;
template<typename FunctionObj,typename Allocator>
void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
;
template<typename FunctionObj>
void
assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
;
template<typename FunctionObj,typename Allocator>
void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
;
template<typename FunctionObj>
bool
assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
;
template<typename FunctionObj,typename Allocator>
bool
assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
;
template<typename FunctionObj>
bool
assign_to(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, function_obj_ref_tag) const
;
template<typename FunctionObj,typename Allocator>
bool
assign_to_a(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, Allocator, function_obj_ref_tag) const
;
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
{
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 ;
struct clear_type {};
public:
static const
int args = 7;
template<typename Args>
struct sig
{
typedef result_type type;
};
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() ;
template<typename Functor>
function7(Functor f
,typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
int>::type = 0
)
;
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
)
;
function7(clear_type*) ;
function7(const function7& f)
;
~function7() ;
result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6) const
;
template<typename Functor>
typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
function7&>::type
operator=(Functor f)
;
template<typename Functor,typename Allocator>
void assign(Functor f, Allocator a)
;
function7& operator=(clear_type*)
;
function7& operator=(const function7& f)
;
void swap(function7& other)
;
void clear()
;
private:
struct dummy {
void nonnull() ;
};
typedef void (dummy::*safe_bool)();
public:
operator safe_bool () const
;
bool operator!() const
;
private:
void assign_to_own(const function7& f)
;
template<typename Functor>
void assign_to(Functor f)
;
template<typename Functor,typename Allocator>
void assign_to_a(Functor f,Allocator a)
;
void move_assign(function7& f)
;
};
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
void swap(function7<
R ,
T0 , T1 , T2 , T3 , T4 , T5 , T6
>& f1,
function7<
R ,
T0 , T1 , T2 , T3 , T4 , T5 , T6
>& 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>& );
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() ;
template<typename Functor>
function(Functor f
,typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
int>::type = 0
)
;
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
)
;
function(clear_type*) ;
function(const self_type& f) ;
function(const base_type& f) ;
self_type& operator=(const self_type& f)
;
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& operator=(clear_type*)
;
self_type& operator=(const base_type& f)
;
};
}
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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;
};
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;
};
};
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
;
template<typename F,typename Allocator>
bool assign_to_a(F f, function_buffer& functor, Allocator a) const
;
void clear(function_buffer& functor) const
;
private:
template<typename FunctionPtr>
bool
assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
;
template<typename FunctionPtr,typename Allocator>
bool
assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
;
template<typename MemberPtr>
bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
;
template<typename MemberPtr,typename Allocator>
bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
;
template<typename FunctionObj>
void
assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
;
template<typename FunctionObj,typename Allocator>
void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
;
template<typename FunctionObj>
void
assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
;
template<typename FunctionObj,typename Allocator>
void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
;
template<typename FunctionObj>
bool
assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
;
template<typename FunctionObj,typename Allocator>
bool
assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
;
template<typename FunctionObj>
bool
assign_to(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, function_obj_ref_tag) const
;
template<typename FunctionObj,typename Allocator>
bool
assign_to_a(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, Allocator, function_obj_ref_tag) const
;
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
{
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 ;
struct clear_type {};
public:
static const
int args = 8;
template<typename Args>
struct sig
{
typedef result_type type;
};
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() ;
template<typename Functor>
function8(Functor f
,typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
int>::type = 0
)
;
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
)
;
function8(clear_type*) ;
function8(const function8& f)
;
~function8() ;
result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7) const
;
template<typename Functor>
typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
function8&>::type
operator=(Functor f)
;
template<typename Functor,typename Allocator>
void assign(Functor f, Allocator a)
;
function8& operator=(clear_type*)
;
function8& operator=(const function8& f)
;
void swap(function8& other)
;
void clear()
;
private:
struct dummy {
void nonnull() ;
};
typedef void (dummy::*safe_bool)();
public:
operator safe_bool () const
;
bool operator!() const
;
private:
void assign_to_own(const function8& f)
;
template<typename Functor>
void assign_to(Functor f)
;
template<typename Functor,typename Allocator>
void assign_to_a(Functor f,Allocator a)
;
void move_assign(function8& f)
;
};
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
void swap(function8<
R ,
T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
>& f1,
function8<
R ,
T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
>& 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>& );
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() ;
template<typename Functor>
function(Functor f
,typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
int>::type = 0
)
;
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
)
;
function(clear_type*) ;
function(const self_type& f) ;
function(const base_type& f) ;
self_type& operator=(const self_type& f)
;
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& operator=(clear_type*)
;
self_type& operator=(const base_type& f)
;
};
}
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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;
};
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;
};
};
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
;
template<typename F,typename Allocator>
bool assign_to_a(F f, function_buffer& functor, Allocator a) const
;
void clear(function_buffer& functor) const
;
private:
template<typename FunctionPtr>
bool
assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
;
template<typename FunctionPtr,typename Allocator>
bool
assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
;
template<typename MemberPtr>
bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
;
template<typename MemberPtr,typename Allocator>
bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
;
template<typename FunctionObj>
void
assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
;
template<typename FunctionObj,typename Allocator>
void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
;
template<typename FunctionObj>
void
assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
;
template<typename FunctionObj,typename Allocator>
void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
;
template<typename FunctionObj>
bool
assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
;
template<typename FunctionObj,typename Allocator>
bool
assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
;
template<typename FunctionObj>
bool
assign_to(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, function_obj_ref_tag) const
;
template<typename FunctionObj,typename Allocator>
bool
assign_to_a(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, Allocator, function_obj_ref_tag) const
;
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
{
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 ;
struct clear_type {};
public:
static const
int args = 9;
template<typename Args>
struct sig
{
typedef result_type type;
};
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() ;
template<typename Functor>
function9(Functor f
,typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
int>::type = 0
)
;
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
)
;
function9(clear_type*) ;
function9(const function9& f)
;
~function9() ;
result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8) const
;
template<typename Functor>
typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
function9&>::type
operator=(Functor f)
;
template<typename Functor,typename Allocator>
void assign(Functor f, Allocator a)
;
function9& operator=(clear_type*)
;
function9& operator=(const function9& f)
;
void swap(function9& other)
;
void clear()
;
private:
struct dummy {
void nonnull() ;
};
typedef void (dummy::*safe_bool)();
public:
operator safe_bool () const
;
bool operator!() const
;
private:
void assign_to_own(const function9& f)
;
template<typename Functor>
void assign_to(Functor f)
;
template<typename Functor,typename Allocator>
void assign_to_a(Functor f,Allocator a)
;
void move_assign(function9& f)
;
};
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
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)
;
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>& );
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() ;
template<typename Functor>
function(Functor f
,typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
int>::type = 0
)
;
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
)
;
function(clear_type*) ;
function(const self_type& f) ;
function(const base_type& f) ;
self_type& operator=(const self_type& f)
;
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& operator=(clear_type*)
;
self_type& operator=(const base_type& f)
;
};
}
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
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;
};
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;
};
};
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
;
template<typename F,typename Allocator>
bool assign_to_a(F f, function_buffer& functor, Allocator a) const
;
void clear(function_buffer& functor) const
;
private:
template<typename FunctionPtr>
bool
assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
;
template<typename FunctionPtr,typename Allocator>
bool
assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
;
template<typename MemberPtr>
bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
;
template<typename MemberPtr,typename Allocator>
bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
;
template<typename FunctionObj>
void
assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
;
template<typename FunctionObj,typename Allocator>
void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
;
template<typename FunctionObj>
void
assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
;
template<typename FunctionObj,typename Allocator>
void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
;
template<typename FunctionObj>
bool
assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
;
template<typename FunctionObj,typename Allocator>
bool
assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
;
template<typename FunctionObj>
bool
assign_to(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, function_obj_ref_tag) const
;
template<typename FunctionObj,typename Allocator>
bool
assign_to_a(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, Allocator, function_obj_ref_tag) const
;
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
{
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 ;
struct clear_type {};
public:
static const
int args = 10;
template<typename Args>
struct sig
{
typedef result_type type;
};
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() ;
template<typename Functor>
function10(Functor f
,typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
int>::type = 0
)
;
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
)
;
function10(clear_type*) ;
function10(const function10& f)
;
~function10() ;
result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9) const
;
template<typename Functor>
typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
function10&>::type
operator=(Functor f)
;
template<typename Functor,typename Allocator>
void assign(Functor f, Allocator a)
;
function10& operator=(clear_type*)
;
function10& operator=(const function10& f)
;
void swap(function10& other)
;
void clear()
;
private:
struct dummy {
void nonnull() ;
};
typedef void (dummy::*safe_bool)();
public:
operator safe_bool () const
;
bool operator!() const
;
private:
void assign_to_own(const function10& f)
;
template<typename Functor>
void assign_to(Functor f)
;
template<typename Functor,typename Allocator>
void assign_to_a(Functor f,Allocator a)
;
void move_assign(function10& f)
;
};
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
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)
;
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>& );
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() ;
template<typename Functor>
function(Functor f
,typename enable_if_c<
(boost::type_traits::ice_not<
(is_integral<Functor>::value)>::value),
int>::type = 0
)
;
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
)
;
function(clear_type*) ;
function(const self_type& f) ;
function(const base_type& f) ;
self_type& operator=(const self_type& f)
;
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& operator=(clear_type*)
;
self_type& operator=(const base_type& f)
;
};
}
namespace boost {
namespace serialization {
template<class T>
struct pfto_wrapper {
const T & t;
operator const T & ();
pfto_wrapper (const T & rhs) ;
};
template<class T>
pfto_wrapper< T > make_pfto_wrapper(const T & t, int);
template<class T>
pfto_wrapper< T > make_pfto_wrapper(const pfto_wrapper< T > & t, int);
}
}
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;
}
}
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;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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)
;
~__timepunct_cache();
private:
__timepunct_cache&
operator=(const __timepunct_cache&);
explicit
__timepunct_cache(const __timepunct_cache&);
};
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 __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);
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
;
void
_M_time_formats(const _CharT** __time) const
;
void
_M_date_time_formats(const _CharT** __dt) const
;
void
_M_am_pm_format(const _CharT* __ampm) const
;
void
_M_am_pm(const _CharT** __ampm) const
;
void
_M_days(const _CharT** __days) const
;
void
_M_days_abbreviated(const _CharT** __days) const
;
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 ();
}
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);
}
}
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace __cxx11 {
template<typename _CharT, typename _InIter>
class time_get : public locale::facet, public time_base
{
public:
typedef _CharT char_type;
typedef _InIter iter_type;
static locale::id id;
explicit
time_get(size_t __refs = 0)
: facet (__refs) { }
dateorder
date_order() const
{ return this->do_date_order(); }
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); }
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); }
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); }
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); }
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() { }
virtual dateorder
do_date_order() const;
virtual iter_type
do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const;
virtual iter_type
do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const;
virtual iter_type
do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
ios_base::iostate& __err, tm* __tm) const;
virtual iter_type
do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
ios_base::iostate& __err, tm* __tm) const;
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() { }
};
}
template<typename _CharT, typename _OutIter>
class time_put : public locale::facet
{
public:
typedef _CharT char_type;
typedef _OutIter iter_type;
static locale::id id;
explicit
time_put(size_t __refs = 0)
: facet(__refs) { }
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
const _CharT* __beg, const _CharT* __end) const;
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()
{ }
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() { }
};
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;
}
}
namespace __cxx11 {
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;
explicit
moneypunct(size_t __refs = 0)
: facet(__refs), _M_data(0)
{ _M_initialize_moneypunct(); }
explicit
moneypunct(__cache_type* __cache, size_t __refs = 0)
: facet(__refs), _M_data(__cache)
{ _M_initialize_moneypunct(); }
explicit
moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
: facet(__refs), _M_data(0)
{ _M_initialize_moneypunct(__cloc, __s); }
char_type
decimal_point() const
{ return this->do_decimal_point(); }
char_type
thousands_sep() const
{ return this->do_thousands_sep(); }
string
grouping() const
{ return this->do_grouping(); }
string_type
curr_symbol() const
{ return this->do_curr_symbol(); }
string_type
positive_sign() const
{ return this->do_positive_sign(); }
string_type
negative_sign() const
{ return this->do_negative_sign(); }
int
frac_digits() const
{ return this->do_frac_digits(); }
pattern
pos_format() const
{ return this->do_pos_format(); }
pattern
neg_format() const
{ return this->do_neg_format(); }
protected:
virtual
~moneypunct();
virtual char_type
do_decimal_point() const
{ return _M_data->_M_decimal_point; }
virtual char_type
do_thousands_sep() const
{ return _M_data->_M_thousands_sep; }
virtual string
do_grouping() const
{ return _M_data->_M_grouping; }
virtual string_type
do_curr_symbol() const
{ return _M_data->_M_curr_symbol; }
virtual string_type
do_positive_sign() const
{ return _M_data->_M_positive_sign; }
virtual string_type
do_negative_sign() const
{ return _M_data->_M_negative_sign; }
virtual int
do_frac_digits() const
{ return _M_data->_M_frac_digits; }
virtual pattern
do_pos_format() const
{ return _M_data->_M_pos_format; }
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;
}
namespace __cxx11 {
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;
explicit
money_get(size_t __refs = 0) : facet(__refs) { }
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); }
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() { }
virtual iter_type
do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
ios_base::iostate& __err, long double& __units) const;
virtual iter_type
do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
ios_base::iostate& __err, string_type& __digits) const;
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;
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;
explicit
money_put(size_t __refs = 0) : facet(__refs) { }
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); }
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() { }
virtual iter_type
do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
long double __units) const;
virtual iter_type
do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
const string_type& __digits) const;
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;
};
namespace __cxx11 {
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;
explicit
messages(size_t __refs = 0);
explicit
messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
catalog
open(const basic_string<char>& __s, const locale& __loc) const
{ return this->do_open(__s, __loc); }
catalog
open(const basic_string<char>&, const locale&, const char*) const;
string_type
get(catalog __c, int __set, int __msgid, const string_type& __s) const
{ return this->do_get(__c, __set, __msgid, __s); }
void
close(catalog __c) const
{ return this->do_close(__c); }
protected:
virtual
~messages();
virtual catalog
do_open(const basic_string<char>&, const locale&) const;
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()
{ }
};
}
}
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 ();
}
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);
}
}
template<>
typename messages<char>::catalog
messages<char>::do_open(const basic_string<char>&,
const locale&) const;
template<>
void
messages<char>::do_close(catalog) const;
template<>
typename messages<wchar_t>::catalog
messages<wchar_t>::do_open(const basic_string<char>&,
const locale&) const;
template<>
void
messages<wchar_t>::do_close(catalog) const;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
class codecvt_base
{
public:
enum result
{
ok,
partial,
error,
noconv
};
};
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;
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);
}
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); }
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() { }
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;
};
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>
{
friend class messages<char>;
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>
{
friend class messages<wchar_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&);
}
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)
{
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
{
const string& __g = __mp.grouping();
_M_grouping_size = __g.size();
__grouping = new char[_M_grouping_size];
__g.copy(__grouping, _M_grouping_size);
_M_use_grouping = (_M_grouping_size
&& static_cast<signed char>(__grouping[0]) > 0
&& (__grouping[0]
!= __gnu_cxx::__numeric_traits<char>::__max));
const basic_string<_CharT>& __cs = __mp.curr_symbol();
_M_curr_symbol_size = __cs.size();
__curr_symbol = new _CharT[_M_curr_symbol_size];
__cs.copy(__curr_symbol, _M_curr_symbol_size);
const basic_string<_CharT>& __ps = __mp.positive_sign();
_M_positive_sign_size = __ps.size();
__positive_sign = new _CharT[_M_positive_sign_size];
__ps.copy(__positive_sign, _M_positive_sign_size);
const basic_string<_CharT>& __ns = __mp.negative_sign();
_M_negative_sign_size = __ns.size();
__negative_sign = new _CharT[_M_negative_sign_size];
__ns.copy(__negative_sign, _M_negative_sign_size);
_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);
_M_grouping = __grouping;
_M_curr_symbol = __curr_symbol;
_M_positive_sign = __positive_sign;
_M_negative_sign = __negative_sign;
_M_allocated = true;
}
catch(...)
{
delete [] __grouping;
delete [] __curr_symbol;
delete [] __positive_sign;
delete [] __negative_sign;
throw;
}
}
namespace __cxx11 {
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;
}
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;
}
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);
}
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
{
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
{
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 __cxx11:: money_get<char>;
extern template class __cxx11:: 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 __cxx11:: money_get<wchar_t>;
extern template class __cxx11:: 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&);
}
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&);
};
}
}
namespace boost {
namespace serialization {
template<class E> inline void throw_exception(E const & e){
throw e;
}
}
}
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();
};
}
}
namespace boost {
namespace archive {
class xml_archive_exception :
public virtual boost::archive::archive_exception
{
public:
typedef enum {
xml_archive_parsing_error,
xml_archive_tag_mismatch,
xml_archive_tag_name_error
} exception_code;
xml_archive_exception(
exception_code c,
const char * e1 =
__null
,
const char * e2 =
__null
);
};
}
}
namespace boost {
namespace archive {
extern
const char *
BOOST_ARCHIVE_XML_OBJECT_ID();
extern
const char *
BOOST_ARCHIVE_XML_OBJECT_REFERENCE();
extern
const char *
BOOST_ARCHIVE_XML_CLASS_ID();
extern
const char *
BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE();
extern
const char *
BOOST_ARCHIVE_XML_CLASS_NAME();
extern
const char *
BOOST_ARCHIVE_XML_TRACKING();
extern
const char *
BOOST_ARCHIVE_XML_VERSION();
extern
const char *
BOOST_ARCHIVE_XML_SIGNATURE();
}
}
namespace boost
{
using std::iterator;
}
namespace mpl_ {
template< int N > struct arg;
}
namespace boost { namespace mpl { using ::mpl_::arg; } }
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 ) ) ) };
};
};
}
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;
}
}}
namespace boost {
namespace iterators {
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
>
>
>
>
>
{};
}
template <class Cat>
struct iterator_category_to_traversal
: mpl::eval_if<
is_convertible<Cat,incrementable_traversal_tag>
, mpl::identity<Cat>
, boost::iterators::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
>
{};
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
>
>
>
>
>
{
};
namespace detail {
using iterators::pure_traversal_tag;
}
template <class Iterator = mpl::_1>
struct pure_iterator_traversal
: pure_traversal_tag<typename iterator_traversal<Iterator>::type>
{};
}
using iterators::no_traversal_tag;
using iterators::incrementable_traversal_tag;
using iterators::single_pass_traversal_tag;
using iterators::forward_traversal_tag;
using iterators::bidirectional_traversal_tag;
using iterators::random_access_traversal_tag;
using iterators::iterator_category_to_traversal;
using iterators::iterator_traversal;
namespace detail {
using iterators::pure_traversal_tag;
}
}
namespace boost {
namespace iterators {
template <typename A, typename B>
struct is_interoperable
: mpl::or_<
is_convertible< A, B >
, is_convertible< B, A > >
{
};
}
using iterators::is_interoperable;
}
namespace boost {
namespace iterators {
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;
};
}
using iterators::iterator_value;
using iterators::iterator_reference;
using iterators::iterator_pointer;
using iterators::iterator_difference;
using iterators::iterator_category;
}
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> { }; }
}}
namespace boost {
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; };
}
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_
{
};
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_
{
};
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
>
>
{
};
}
using namespace indirect_traits;
}}
namespace boost {
namespace iterators {
struct use_default;
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>
>
{};
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_145 = 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_147 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_iterator_category<Category>))0, 1 ) ) ) };
enum { mpl_assertion_in_line_148 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_category<Traversal>))0, 1 ) ) ) };
enum { mpl_assertion_in_line_149 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_traversal<Category>))0, 1 ) ) ) };
enum { mpl_assertion_in_line_151 = 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_160 = 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>
>
{
};
}}}
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
{
};
};
template <class Cond,
class Return>
struct enable_if
: enabled<(Cond::value)>::template base<Return>
{
};
}
}
namespace boost { namespace mpl {
template< typename Value > struct always
{
template<
typename T1 = na , typename T2 = na , typename T3 = na , typename T4 = na , typename T5 = na
>
struct apply
{
typedef Value type;
};
};
}}
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;
}}
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;
}}
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> { }; }
}}
namespace boost { namespace mpl {
template<
typename T = na
, int not_le_ = 0
>
struct protect : T
{
typedef protect type;
};
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> { }; }
}}
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;
};
};
}}
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<U> 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; };
}}}
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
>
{
};
};
}}
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;
};
}}}
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> { }; }
}}
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 >
{
};
}}
namespace boost {
namespace iterators {
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< typename CategoryOrTraversal, typename Required >
struct is_traversal_at_least :
public boost::is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, Required >
{};
template <
class Facade1
, class Facade2
, class Return
>
struct enable_if_interoperable :
public boost::iterators::enable_if<
is_interoperable< Facade1, Facade2 >
, Return
>
{};
template <
class Facade1
, class Facade2
, class Return
>
struct enable_if_interoperable_and_random_access_traversal :
public boost::iterators::enable_if<
mpl::and_<
is_interoperable< Facade1, Facade2 >
, is_traversal_at_least< typename iterator_category< Facade1 >::type, random_access_traversal_tag >
, is_traversal_at_least< typename iterator_category< Facade2 >::type, random_access_traversal_tag >
>
, 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::iterators::detail::iterator_writability_disabled<ValueParam,Reference>
, add_pointer<const value_type>
, add_pointer<value_type>
>::type pointer;
};
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;
};
template <class Reference, class Value>
struct is_non_proxy_reference
: is_convertible<
typename remove_reference<Reference>::type
const volatile*
, Value const volatile*
>
{};
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);
}
};
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
:
mpl::eval_if<
is_convertible<I2,I1>
, iterator_difference<I1>
, iterator_difference<I2>
>
{};
};
template <
class Derived
, class Value
, class CategoryOrTraversal
, class Reference
, class Difference
, bool IsBidirectionalTraversal
, bool IsRandomAccessTraversal
>
class iterator_facade_base;
}
class iterator_core_access
{
template <class I, class V, class TC, class R, class D> friend class iterator_facade;
template <class I, class V, class TC, class R, class D, bool IsBidirectionalTraversal, bool IsRandomAccessTraversal>
friend class detail::iterator_facade_base;
template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::iterators::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::iterators::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::iterators::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::iterators::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::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::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::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::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::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::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::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::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::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::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 typename boost::iterators::enable_if< boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, Derived >::type 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 typename boost::iterators::enable_if< boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, Derived >::type 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<I const*>(&facade);
}
private:
iterator_core_access()
;
};
namespace detail {
template <
class Derived
, class Value
, class CategoryOrTraversal
, class Reference
, class Difference
>
class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
{
private:
typedef boost::iterators::detail::iterator_facade_types<
Value, CategoryOrTraversal, Reference, Difference
> associated_types;
typedef boost::iterators::detail::operator_arrow_dispatch<
Reference
, typename associated_types::pointer
> operator_arrow_dispatch_;
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;
public:
reference operator*() const
{
return iterator_core_access::dereference(this->derived());
}
pointer operator->() const
{
return operator_arrow_dispatch_::apply(*this->derived());
}
Derived& operator++()
{
iterator_core_access::increment(this->derived());
return this->derived();
}
protected:
Derived& derived()
{
return *static_cast<Derived*>(this);
}
Derived const& derived() const
{
return *static_cast<Derived const*>(this);
}
};
template <
class Derived
, class Value
, class CategoryOrTraversal
, class Reference
, class Difference
>
class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > :
public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
{
public:
Derived& operator--()
{
iterator_core_access::decrement(this->derived());
return this->derived();
}
Derived operator--(int)
{
Derived tmp(this->derived());
--*this;
return tmp;
}
};
template <
class Derived
, class Value
, class CategoryOrTraversal
, class Reference
, class Difference
>
class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, true > :
public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false >
{
private:
typedef iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > base_type;
public:
typedef typename base_type::reference reference;
typedef typename base_type::difference_type difference_type;
public:
typename boost::iterators::detail::operator_brackets_result<Derived, Value, reference>::type
operator[](difference_type n) const
{
typedef boost::iterators::detail::use_operator_brackets_proxy<Value, Reference> use_proxy;
return boost::iterators::detail::make_operator_brackets_result<Derived>(
this->derived() + n
, use_proxy()
);
}
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;
}
};
}
template <
class Derived
, class Value
, class CategoryOrTraversal
, class Reference = Value&
, class Difference = std::ptrdiff_t
>
class iterator_facade :
public detail::iterator_facade_base<
Derived,
Value,
CategoryOrTraversal,
Reference,
Difference,
detail::is_traversal_at_least< CategoryOrTraversal, bidirectional_traversal_tag >::value,
detail::is_traversal_at_least< CategoryOrTraversal, random_access_traversal_tag >::value
>
{
protected:
typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_;
};
template <class I, class V, class TC, class R, class D>
inline typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type
operator++(
iterator_facade<I,V,TC,R,D>& i
, int
)
{
typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type
tmp(*static_cast<I*>(&i));
++i;
return tmp;
}
template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::iterators::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::iterators::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) {
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
( is_interoperable< Derived1, Derived2 >::value )
) == 0 ? false : true) >)> boost_static_assert_typedef_890 __attribute__((unused))
; 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::iterators::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::iterators::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) {
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
( is_interoperable< Derived1, Derived2 >::value )
) == 0 ? false : true) >)> boost_static_assert_typedef_891 __attribute__((unused))
; 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::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::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) {
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )
) == 0 ? false : true) >)> boost_static_assert_typedef_920 __attribute__((unused))
; 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::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::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) {
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )
) == 0 ? false : true) >)> boost_static_assert_typedef_921 __attribute__((unused))
; 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::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::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) {
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )
) == 0 ? false : true) >)> boost_static_assert_typedef_922 __attribute__((unused))
; 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::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::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) {
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )
) == 0 ? false : true) >)> boost_static_assert_typedef_923 __attribute__((unused))
; 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::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::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) {
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )
) == 0 ? false : true) >)> boost_static_assert_typedef_933 __attribute__((unused))
; return iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
template <class Derived, class V, class TC, class R, class D> inline typename boost::iterators::enable_if< boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, Derived >::type 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 typename boost::iterators::enable_if< boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, Derived >::type 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; }
}
using iterators::iterator_core_access;
using iterators::iterator_facade;
}
namespace boost {
namespace iterators {
struct use_default;
}
using iterators::use_default;
template<class To>
struct is_convertible<use_default,To>
: mpl::false_ {};
namespace iterators {
namespace detail
{
struct enable_type;
}
template<typename From, typename To>
struct enable_if_convertible
: iterators::enable_if<
is_convertible<From, To>
, boost::iterators::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::iterators::detail::ia_dflt_help<
Value
, mpl::eval_if<
is_same<Reference,use_default>
, iterator_value<Base>
, remove_reference<Reference>
>
>::type
, typename boost::iterators::detail::ia_dflt_help<
Traversal
, iterator_traversal<Base>
>::type
, typename boost::iterators::detail::ia_dflt_help<
Reference
, mpl::eval_if<
is_same<Value,use_default>
, iterator_reference<Base>
, add_reference<Value>
>
>::type
, typename boost::iterators::detail::ia_dflt_help<
Difference, iterator_difference<Base>
>::type
>
type;
};
template <class Tr1, class Tr2>
inline void iterator_adaptor_assert_traversal ()
{
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((
(is_convertible<Tr1, Tr2>::value)
) == 0 ? false : true) >)> boost_static_assert_typedef_214 __attribute__((unused))
;
}
}
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::iterators::detail::iterator_adaptor_base<
Derived, Base, Value, Traversal, Reference, Difference
>::type
{
friend class iterator_core_access;
protected:
typedef typename boost::iterators::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::iterators::detail::iterator_adaptor_assert_traversal<my_traversal, random_access_traversal_tag>();
m_iterator += n;
}
void increment() { ++m_iterator; }
void decrement()
{
boost::iterators::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::iterators::detail::iterator_adaptor_assert_traversal<my_traversal, random_access_traversal_tag>();
return y.base() - m_iterator;
}
private:
Base m_iterator;
};
}
using iterators::iterator_adaptor;
using iterators::enable_if_convertible;
}
namespace boost { namespace detail {
namespace is_incrementable_
{
struct tag {};
struct any { template <class T> any(T const&); };
tag operator++(any const&);
tag operator++(any const&,int);
tag operator,(tag,int);
char (& check_(tag) )[2];
template <class T>
char check_(T const&);
template <class T>
struct impl
{
static typename boost::remove_cv<T>::type& x;
static const
bool value = sizeof(is_incrementable_::check_((++x,0))) == 1
;
};
template <class T>
struct postfix_impl
{
static typename boost::remove_cv<T>::type& x;
static const
bool value = sizeof(is_incrementable_::check_((x++,0))) == 1
;
};
}
template<typename T>
struct is_incrementable
: public ::boost::integral_constant<bool,::boost::detail::is_incrementable_::impl<T>::value>
{
};
template<typename T>
struct is_postfix_incrementable
: public ::boost::integral_constant<bool,::boost::detail::is_incrementable_::postfix_impl<T>::value>
{
};
}
}
namespace boost {
namespace detail
{
template <class P>
struct smart_ptr_pointee
{
typedef typename P::element_type type;
};
template <class Iterator>
struct iterator_pointee
{
typedef typename iterator_traits<Iterator>::value_type value_type;
struct impl
{
template <class T>
static char test(T const&);
static char (& test(value_type&) )[2];
static Iterator& x;
};
static const
bool is_constant = sizeof(impl::test(*impl::x)) == 1;
typedef typename mpl::if_c<
is_constant
, typename add_const<value_type>::type
, value_type
>::type type;
};
}
template <class P>
struct pointee
: mpl::eval_if<
detail::is_incrementable<P>
, detail::iterator_pointee<P>
, detail::smart_ptr_pointee<P>
>
{
};
}
namespace boost {
namespace archive {
namespace iterators {
template<class Derived, class Base>
class unescape
: public boost::iterator_adaptor<
unescape<Derived, Base>,
Base,
typename pointee<Base>::type,
single_pass_traversal_tag,
typename pointee<Base>::type
>
{
friend class boost::iterator_core_access;
typedef typename boost::iterator_adaptor<
unescape<Derived, Base>,
Base,
typename pointee<Base>::type,
single_pass_traversal_tag,
typename pointee<Base>::type
> super_t;
typedef unescape<Derived, Base> this_t;
public:
typedef typename this_t::value_type value_type;
typedef typename this_t::reference reference;
private:
value_type dereference_impl() {
if(! m_full){
m_current_value = static_cast<Derived *>(this)->drain();
m_full = true;
}
return m_current_value;
}
reference dereference() const {
return const_cast<this_t *>(this)->dereference_impl();
}
value_type m_current_value;
bool m_full;
void increment(){
++(this->base_reference());
dereference_impl();
m_full = false;
};
public:
unescape(Base base) :
super_t(base),
m_full(false)
{}
};
}
}
}
namespace boost {
namespace archive {
namespace iterators {
class dataflow_exception : public std::exception
{
public:
typedef enum {
invalid_6_bitcode,
invalid_base64_character,
invalid_xml_escape_sequence,
comparison_not_permitted,
invalid_conversion,
other_exception
} exception_code;
exception_code code;
dataflow_exception(exception_code c = other_exception) : code(c)
{}
virtual const char *what( ) const throw( )
{
const char *msg = "unknown exception code";
switch(code){
case invalid_6_bitcode:
msg = "attempt to encode a value > 6 bits";
break;
case invalid_base64_character:
msg = "attempt to decode a value not in base64 char set";
break;
case invalid_xml_escape_sequence:
msg = "invalid xml escape_sequence";
break;
case comparison_not_permitted:
msg = "cannot invoke iterator comparison now";
break;
case invalid_conversion:
msg = "invalid multbyte/wide char conversion";
break;
default:
(static_cast<void> (0))
;
break;
}
return msg;
}
};
}
}
}
namespace boost {
namespace archive {
namespace iterators {
template<class Base>
class xml_unescape
: public unescape<xml_unescape<Base>, Base>
{
friend class boost::iterator_core_access;
typedef xml_unescape<Base> this_t;
typedef unescape<this_t, Base> super_t;
typedef typename boost::iterator_reference<this_t> reference_type;
reference_type dereference() const {
return unescape<xml_unescape<Base>, Base>::dereference();
}
public:
typedef typename this_t::value_type value_type;
void drain_residue(const char *literal);
value_type drain();
template<class T>
xml_unescape(T start) :
super_t(Base(static_cast< T >(start)))
{}
xml_unescape(const xml_unescape & rhs) :
super_t(rhs.base_reference())
{}
};
template<class Base>
void xml_unescape<Base>::drain_residue(const char * literal){
do{
if(* literal != * ++(this->base_reference()))
boost::serialization::throw_exception(
dataflow_exception(
dataflow_exception::invalid_xml_escape_sequence
)
);
}
while('\0' != * ++literal);
}
template<class Base>
typename xml_unescape<Base>::value_type
xml_unescape<Base>::drain(){
value_type retval = * this->base_reference();
if('&' != retval){
return retval;
}
retval = * ++(this->base_reference());
switch(retval){
case 'l':
drain_residue("t;");
retval = '<';
break;
case 'g':
drain_residue("t;");
retval = '>';
break;
case 'a':
retval = * ++(this->base_reference());
switch(retval){
case 'p':
drain_residue("os;");
retval = '\'';
break;
case 'm':
drain_residue("p;");
retval = '&';
break;
}
break;
case 'q':
drain_residue("uot;");
retval = '"';
break;
}
return retval;
}
}
}
}
using namespace boost::spirit::classic;
namespace boost {
namespace archive {
namespace xml {
template<class T>
struct assign_impl {
T & t;
void operator()(const T t_) const {
t = t_;
}
assign_impl(T & t_)
: t(t_)
{}
};
template<>
struct assign_impl<std::string> {
std::string & t;
void operator()(
std::string::const_iterator b,
std::string::const_iterator e
) const {
t.resize(0);
while(b != e){
t += * b;
++b;
}
}
assign_impl<std::string> & operator=(
assign_impl<std::string> & rhs
);
assign_impl(std::string & t_)
: t(t_)
{}
};
template<>
struct assign_impl<std::wstring> {
std::wstring & t;
void operator()(
std::wstring::const_iterator b,
std::wstring::const_iterator e
) const {
t.resize(0);
while(b != e){
t += * b;
++b;
}
}
assign_impl(std::wstring & t_)
: t(t_)
{}
};
template<class T>
assign_impl<T> assign_object(T &t){
return assign_impl<T>(t);
}
struct assign_level {
tracking_type & tracking_level;
void operator()(const unsigned int tracking_level_) const {
tracking_level = (0 == tracking_level_) ? false : true;
}
assign_level(tracking_type & tracking_level_)
: tracking_level(tracking_level_)
{}
};
template<class String, class Iterator>
struct append_string {
String & contents;
void operator()(Iterator start, Iterator end) const {
contents.append(start, end);
}
append_string(String & contents_)
: contents(contents_)
{}
};
template<class String>
struct append_char {
String & contents;
void operator()(const unsigned int char_value) const {
const
typename
String::value_type z = char_value;
contents += z;
}
append_char(String & contents_)
: contents(contents_)
{}
};
template<class String, unsigned int c>
struct append_lit {
String & contents;
template<class X, class Y>
void operator()(const X & , const Y & ) const {
const
typename
String::value_type z = c;
contents += z;
}
append_lit(String & contents_)
: contents(contents_)
{}
};
}
template<class CharType>
bool basic_xml_grammar<CharType>::my_parse(
typename
basic_xml_grammar<CharType>::IStream & is,
const rule_t & rule_,
CharType delimiter
) const {
if(is.fail()){
boost::serialization::throw_exception(
archive_exception(archive_exception::input_stream_error)
);
}
boost::io::ios_flags_saver ifs(is);
is >> std::noskipws;
std::basic_string<CharType> arg;
CharType val;
do{
typename
basic_xml_grammar<CharType>::IStream::int_type
result = is.get();
if(is.fail())
return false;
val = static_cast<CharType>(result);
arg += val;
}
while(val != delimiter);
parse_info<
typename
std::basic_string<CharType>::iterator>
result = boost::spirit::classic::parse(arg.begin(), arg.end(), rule_);
return result.hit;
}
template<class CharType>
bool basic_xml_grammar<CharType>::parse_start_tag(
typename
basic_xml_grammar<CharType>::IStream & is
){
rv.class_name.resize(0);
return my_parse(is, STag);
}
template<class CharType>
bool basic_xml_grammar<CharType>::parse_end_tag(IStream & is) const {
return my_parse(is, ETag);
}
template<class CharType>
bool basic_xml_grammar<CharType>::parse_string(IStream & is, StringType & s){
rv.contents.resize(0);
bool result = my_parse(is, content, '<');
is.putback('<');
if(result)
s = rv.contents;
return result;
}
template<class CharType>
basic_xml_grammar<CharType>::basic_xml_grammar(){
init_chset();
S =
+(Sch)
;
NameHead = (Letter | '_' | ':');
NameTail = *NameChar ;
Name =
NameHead >> NameTail
;
Eq =
!S >> '=' >> !S
;
AttributeList =
*(S >> Attribute)
;
STag =
!S
>> '<'
>> Name [xml::assign_object(rv.object_name)]
>> AttributeList
>> !S
>> '>'
;
ETag =
!S
>> "</"
>> Name [xml::assign_object(rv.object_name)]
>> !S
>> '>'
;
CharDataChars = +(anychar_p - chset_p(L"&<"));
CharData =
CharDataChars [
xml::append_string<
StringType,
typename
std::basic_string<CharType>::const_iterator
>(rv.contents)
]
;
CharRef1 =
str_p(L"&#") >> uint_p [xml::append_char<StringType>(rv.contents)] >> L';'
;
CharRef2 =
str_p(L"&#x") >> hex_p [xml::append_char<StringType>(rv.contents)] >> L';'
;
CharRef = CharRef1 | CharRef2 ;
AmpRef = str_p(L"&")[xml::append_lit<StringType, L'&'>(rv.contents)];
LTRef = str_p(L"<")[xml::append_lit<StringType, L'<'>(rv.contents)];
GTRef = str_p(L">")[xml::append_lit<StringType, L'>'>(rv.contents)];
AposRef = str_p(L"'")[xml::append_lit<StringType, L'\''>(rv.contents)];
QuoteRef = str_p(L""")[xml::append_lit<StringType, L'"'>(rv.contents)];
Reference =
AmpRef
| LTRef
| GTRef
| AposRef
| QuoteRef
| CharRef
;
content =
L"<"
| +(Reference | CharData) >> L"<"
;
ClassIDAttribute =
str_p(BOOST_ARCHIVE_XML_CLASS_ID()) >> NameTail
>> Eq
>> L'"'
>> int_p [xml::assign_object(rv.class_id)]
>> L'"'
;
ObjectIDAttribute = (
str_p(BOOST_ARCHIVE_XML_OBJECT_ID())
|
str_p(BOOST_ARCHIVE_XML_OBJECT_REFERENCE())
)
>> NameTail
>> Eq
>> L'"'
>> L'_'
>> uint_p [xml::assign_object(rv.object_id)]
>> L'"'
;
AmpName = str_p(L"&")[xml::append_lit<StringType, L'&'>(rv.class_name)];
LTName = str_p(L"<")[xml::append_lit<StringType, L'<'>(rv.class_name)];
GTName = str_p(L">")[xml::append_lit<StringType, L'>'>(rv.class_name)];
ClassNameChar =
AmpName
| LTName
| GTName
| (anychar_p - chset_p(L"\"")) [xml::append_char<StringType>(rv.class_name)]
;
ClassName =
* ClassNameChar
;
ClassNameAttribute =
str_p(BOOST_ARCHIVE_XML_CLASS_NAME())
>> Eq
>> L'"'
>> ClassName
>> L'"'
;
TrackingAttribute =
str_p(BOOST_ARCHIVE_XML_TRACKING())
>> Eq
>> L'"'
>> uint_p [xml::assign_level(rv.tracking_level)]
>> L'"'
;
VersionAttribute =
str_p(BOOST_ARCHIVE_XML_VERSION())
>> Eq
>> L'"'
>> uint_p [xml::assign_object(rv.version)]
>> L'"'
;
UnusedAttribute =
Name
>> Eq
>> L'"'
>> !CharData
>> L'"'
;
Attribute =
ClassIDAttribute
| ObjectIDAttribute
| ClassNameAttribute
| TrackingAttribute
| VersionAttribute
| UnusedAttribute
;
XMLDeclChars = *(anychar_p - chset_p(L"?>"));
XMLDecl =
!S
>> str_p(L"<?xml")
>> S
>> str_p(L"version")
>> Eq
>> str_p(L"\"1.0\"")
>> XMLDeclChars
>> !S
>> str_p(L"?>")
;
DocTypeDeclChars = *(anychar_p - chset_p(L">"));
DocTypeDecl =
!S
>> str_p(L"<!DOCTYPE")
>> DocTypeDeclChars
>> L'>'
;
SignatureAttribute =
str_p(L"signature")
>> Eq
>> L'"'
>> Name [xml::assign_object(rv.class_name)]
>> L'"'
;
SerializationWrapper =
!S
>> str_p(L"<boost_serialization")
>> S
>> ( (SignatureAttribute >> S >> VersionAttribute)
| (VersionAttribute >> S >> SignatureAttribute)
)
>> !S
>> L'>'
;
}
template<class CharType>
void basic_xml_grammar<CharType>::init(IStream & is){
init_chset();
if(! my_parse(is, XMLDecl))
boost::serialization::throw_exception(
xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
);
if(! my_parse(is, DocTypeDecl))
boost::serialization::throw_exception(
xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
);
if(! my_parse(is, SerializationWrapper))
boost::serialization::throw_exception(
xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
);
if(! std::equal(rv.class_name.begin(), rv.class_name.end(), BOOST_ARCHIVE_SIGNATURE()))
boost::serialization::throw_exception(
archive_exception(archive_exception::invalid_signature)
);
}
template<class CharType>
void basic_xml_grammar<CharType>::windup(IStream & is){
if(is.fail() || is.eof())
return;
my_parse(is, ETag);
}
}
}
namespace boost {
namespace archive {
template class basic_xml_grammar<char>;
}
}